Tempus_IntegratorForwardSensitivity_decl.hpp

Go to the documentation of this file.

//@HEADER
// *****************************************************************************
//          Tempus: Time Integration and Sensitivity Analysis Package
//
// Copyright 2017 NTESS and the Tempus contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
//@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 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<const Thyra::VectorBase<Scalar>> getG() const;
  virtual Teuchos::RCP<const Thyra::MultiVectorBase<Scalar>> getDgDp() 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;

  SensitivityStepMode getStepMode() const;

 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,
    const Teuchos::RCP<Thyra::ModelEvaluator<Scalar>> &sens_residual_model,
    const Teuchos::RCP<Thyra::ModelEvaluator<Scalar>> &sens_solve_model);


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


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


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

}  // namespace Tempus

#endif  // Tempus_IntegratorForwardSensitivity_decl_hpp