Tempus_StepperStaggeredForwardSensitivity_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_StepperStaggeredForwardSensitivity_decl_hpp
#define Tempus_StepperStaggeredForwardSensitivity_decl_hpp

#include "Tempus_config.hpp"
#include "Tempus_Stepper.hpp"
#include "Tempus_SensitivityModelEvaluatorBase.hpp"

namespace Tempus {

enum class SensitivityStepMode { Forward,
                                 Sensitivity,
                                 Combined,
                                 Adjoint };

template <class Scalar>
class StepperStaggeredForwardSensitivity
  : virtual public Tempus::Stepper<Scalar>,
    virtual public Teuchos::ParameterListAcceptor {
 public:
  StepperStaggeredForwardSensitivity();


  StepperStaggeredForwardSensitivity(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel,
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >&
          sens_residual_model,
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >&
          sens_solve_model,
      const Teuchos::RCP<Teuchos::ParameterList>& pList      = Teuchos::null,
      const Teuchos::RCP<Teuchos::ParameterList>& sens_pList = Teuchos::null);


  virtual void setModel(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel)
  {
    setModel(appModel, appModel, appModel);
  }
  virtual void setModel(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel,
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >&
          sens_residual_model,
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >&
          sens_solve_model);
  virtual Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > getModel() const;

  virtual void setSolver(
      Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > solver = Teuchos::null);
  virtual Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > getSolver() const
  {
    return stateStepper_->getSolver();
  }

  virtual void setInitialConditions(
      const Teuchos::RCP<SolutionHistory<Scalar> >& /* solutionHistory */)
  {
  }

  virtual void takeStep(
      const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory);

  virtual Teuchos::RCP<Tempus::StepperState<Scalar> > getDefaultStepperState();
  virtual Scalar getOrder() const { return stateStepper_->getOrder(); }
  virtual Scalar getOrderMin() const { return stateStepper_->getOrderMin(); }
  virtual Scalar getOrderMax() const { return stateStepper_->getOrderMax(); }
  virtual Scalar getInitTimeStep(
      const Teuchos::RCP<SolutionHistory<Scalar> >& /* solutionHistory */) const
  {
    return Scalar(1.0e+99);
  }

  virtual bool isExplicit() const
  {
    return stateStepper_->isExplicit() || sensitivityStepper_->isExplicit();
  }
  virtual bool isImplicit() const
  {
    return stateStepper_->isImplicit() || sensitivityStepper_->isImplicit();
  }
  virtual bool isExplicitImplicit() const
  {
    return isExplicit() && isImplicit();
  }

  virtual bool isOneStepMethod() const
  {
    return stateStepper_->isOneStepMethod() &&
           sensitivityStepper_->isOneStepMethod();
  }
  virtual bool isMultiStepMethod() const { return !isOneStepMethod(); }

  virtual OrderODE getOrderODE() const { return FIRST_ORDER_ODE; }

  virtual void setUseFSAL(bool a) { stepperPL_->set<bool>("Use FSAL", a); }
  virtual bool getUseFSAL() const
  {
    return stepperPL_->get<bool>("Use FSAL", false);
  }

  virtual void setICConsistency(std::string s)
  {
    stepperPL_->set<std::string>("Initial Condition Consistency", s);
  }
  virtual std::string getICConsistency() const
  {
    return stepperPL_->get<std::string>("Initial Condition Consistency",
                                        "None");
  }

  virtual void setICConsistencyCheck(bool c)
  {
    stepperPL_->set<bool>("Initial Condition Consistency Check", c);
  }
  virtual bool getICConsistencyCheck() const
  {
    return stepperPL_->get<bool>("Initial Condition Consistency Check", false);
  }

  virtual void setInitialGuess(
      Teuchos::RCP<const Thyra::VectorBase<Scalar> > /* initial_guess */)
  {
  }


  void setParameterList(const Teuchos::RCP<Teuchos::ParameterList>& pl);
  Teuchos::RCP<Teuchos::ParameterList> getNonconstParameterList();
  Teuchos::RCP<Teuchos::ParameterList> unsetParameterList();
  Teuchos::RCP<const Teuchos::ParameterList> getValidParameters() const;
  Teuchos::RCP<Teuchos::ParameterList> getDefaultParameters() const;


  virtual std::string description() const
  {
    return "StepperStaggeredForwardSensitivity";
  }
  virtual void describe(Teuchos::FancyOStream& out,
                        const Teuchos::EVerbosityLevel verbLevel) const;

  virtual bool isValidSetup(Teuchos::FancyOStream& out) const;

  Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_x_space() const;

  virtual Teuchos::RCP<const Teuchos::ParameterList> getParameterList() const
  {
    return stepperPL_;
  }

  SensitivityStepMode getStepMode() const { return stepMode_; }

 private:
  void setParams(const Teuchos::RCP<Teuchos::ParameterList>& pl,
                 const Teuchos::RCP<Teuchos::ParameterList>& spl);

 protected:
  Teuchos::RCP<Teuchos::ParameterList> stepperPL_;
  Teuchos::RCP<Teuchos::ParameterList> sensPL_;
  Teuchos::RCP<Stepper<Scalar> > stateStepper_;
  Teuchos::RCP<Stepper<Scalar> > sensitivityStepper_;
  Teuchos::RCP<SensitivityModelEvaluatorBase<Scalar> > combined_fsa_model_;
  Teuchos::RCP<SensitivityModelEvaluatorBase<Scalar> > fsa_model_;
  Teuchos::RCP<SolutionHistory<Scalar> > stateSolutionHistory_;
  Teuchos::RCP<SolutionHistory<Scalar> > sensSolutionHistory_;
  bool reuse_solver_;
  bool force_W_update_;
  SensitivityStepMode stepMode_;
};

}  // namespace Tempus

#endif  // Tempus_StepperStaggeredForwardSensitivity_decl_hpp