Tempus_IntegratorForwardSensitivity_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_IntegratorForwardSensitivity_decl_hpp
#define Tempus_IntegratorForwardSensitivity_decl_hpp

// Tempus
#include "Tempus_config.hpp"
#include "Tempus_IntegratorBasic.hpp"
#include "Tempus_SensitivityModelEvaluatorBase.hpp"
#include "Tempus_StepperStaggeredForwardSensitivity.hpp"

namespace Tempus {


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

  IntegratorForwardSensitivity(
      const Teuchos::RCP<Thyra::ModelEvaluator<Scalar>> &model,
      const Teuchos::RCP<IntegratorBasic<Scalar>> &integrator,
      const Teuchos::RCP<SensitivityModelEvaluatorBase<Scalar>> &sens_model,
      const Teuchos::RCP<StepperStaggeredForwardSensitivity<Scalar>> &sens_stepper,
      const bool use_combined_method);


  IntegratorForwardSensitivity();

  virtual ~IntegratorForwardSensitivity() {}


  virtual bool advanceTime()
    { return integrator_->advanceTime(); }
  virtual bool advanceTime(const Scalar timeFinal) override
    { return integrator_->advanceTime(timeFinal); }
  virtual void startIntegrator()
    { integrator_->startIntegrator(); }
  virtual void startTimeStep()
    { integrator_->startTimeStep(); }
  virtual void checkTimeStep()
    { integrator_->checkTimeStep(); }
  virtual void endIntegrator()
    { integrator_->endIntegrator(); }
  virtual Teuchos::RCP<Teuchos::ParameterList> getTempusParameterList() override
    { return integrator_->getTempusParameterList(); }
  virtual void setTempusParameterList(Teuchos::RCP<Teuchos::ParameterList> pl) override
    { integrator_->setTempusParameterList(pl); }


  virtual Scalar getTime() const override
    { return integrator_->getTime(); }
  virtual int getIndex() const override
    { return integrator_->getIndex(); }
  virtual Status getStatus() const override
    { return integrator_->getStatus(); }
  // Set Status
  virtual void setStatus(const Status st) override {
    integrator_->setStatus(st);
  }
  virtual Teuchos::RCP<Stepper<Scalar> > getStepper() const override
    { return integrator_->getStepper(); }

  virtual void setStepper(Teuchos::RCP<Thyra::ModelEvaluator<Scalar> > model);

  virtual void setStepper(Teuchos::RCP<Stepper<Scalar> > stepper)
    { integrator_->setStepper(stepper); }
  virtual void initializeSolutionHistory(
    Teuchos::RCP<SolutionState<Scalar> > state = Teuchos::null)
    { integrator_->initializeSolutionHistory(state); }

  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,
    Teuchos::RCP<const Thyra::MultiVectorBase<Scalar> > DxDp0 = Teuchos::null,
    Teuchos::RCP<const Thyra::MultiVectorBase<Scalar> > DxdotDp0 = Teuchos::null,
    Teuchos::RCP<const Thyra::MultiVectorBase<Scalar> > DxdotdotDp0 = Teuchos::null);

  virtual Teuchos::RCP<const SolutionHistory<Scalar> > getSolutionHistory() const override
    { return integrator_->getSolutionHistory(); }
  virtual Teuchos::RCP<SolutionHistory<Scalar> > getNonConstSolutionHistory() override
    { return integrator_->getNonConstSolutionHistory(); }
  virtual void setSolutionHistory(
    Teuchos::RCP<SolutionHistory<Scalar> > sh = Teuchos::null)
    { integrator_->setSolutionHistory(sh); }
  virtual Teuchos::RCP<const TimeStepControl<Scalar> > getTimeStepControl() const override
    { return integrator_->getTimeStepControl(); }
  virtual Teuchos::RCP<TimeStepControl<Scalar> > getNonConstTimeStepControl() override
    { return integrator_->getNonConstTimeStepControl(); }
  virtual void setTimeStepControl(
    Teuchos::RCP<TimeStepControl<Scalar> > tsc = Teuchos::null)
    { integrator_->setTimeStepControl(tsc); }
  virtual Teuchos::RCP<IntegratorObserver<Scalar> > getObserver()
    { return integrator_->getObserver(); }
  virtual void setObserver(
    Teuchos::RCP<IntegratorObserver<Scalar> > obs = Teuchos::null)
    { integrator_->setObserver(obs); }
  virtual void initialize()
    { integrator_->initialize(); }
  virtual Teuchos::RCP<Teuchos::Time> getIntegratorTimer() const override
    { return integrator_->getIntegratorTimer(); }
  virtual Teuchos::RCP<Teuchos::Time> getStepperTimer() const override
    { return integrator_->getStepperTimer(); }

  virtual Teuchos::RCP<const Thyra::VectorBase<Scalar> > getX() const;

  virtual Teuchos::RCP<const Thyra::MultiVectorBase<Scalar> > getDxDp() const;
  virtual Teuchos::RCP<const Thyra::VectorBase<Scalar> > getXDot() const;
  virtual Teuchos::RCP<const Thyra::MultiVectorBase<Scalar> > getDXDotDp() const;
  virtual Teuchos::RCP<const Thyra::VectorBase<Scalar> > getXDotDot() const;
  virtual Teuchos::RCP<const Thyra::MultiVectorBase<Scalar> > getDXDotDotDp() const;

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

  void parseScreenOutput() { integrator_->parseScreenOutput(); }


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

protected:
  Teuchos::RCP<Thyra::ModelEvaluator<Scalar>> model_;
  Teuchos::RCP<IntegratorBasic<Scalar>> integrator_;
  Teuchos::RCP<SensitivityModelEvaluatorBase<Scalar>> sens_model_;
  Teuchos::RCP<StepperStaggeredForwardSensitivity<Scalar>> sens_stepper_;
  bool use_combined_method_;
};


template <class Scalar>
Teuchos::RCP<IntegratorForwardSensitivity<Scalar>>
createIntegratorForwardSensitivity(
    Teuchos::RCP<Teuchos::ParameterList> pList,
    const Teuchos::RCP<Thyra::ModelEvaluator<Scalar>> &model);


template <class Scalar>
Teuchos::RCP<IntegratorForwardSensitivity<Scalar>>
createIntegratorForwardSensitivity();

} // namespace Tempus

#endif // Tempus_IntegratorForwardSensitivity_decl_hpp