Tempus_StepperImplicit_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_StepperImplicit_decl_hpp
#define Tempus_StepperImplicit_decl_hpp
 
// Tempus
#include "Tempus_config.hpp"
#include "Tempus_Stepper.hpp"
#include "Tempus_WrapperModelEvaluatorBasic.hpp"
 
namespace Tempus {

template <class Scalar>
class StepperImplicit : virtual public Tempus::Stepper<Scalar> {
 public:


  virtual void setModel(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel)
      override;
 
  virtual Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > getModel()
      const override
  {
    Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > model;
    if (wrapperModel_ != Teuchos::null) model = wrapperModel_->getAppModel();
    return model;
  }
 
  virtual Teuchos::RCP<const WrapperModelEvaluator<Scalar> > getWrapperModel()
  {
    return wrapperModel_;
  }
 
  virtual void setDefaultSolver();

  virtual void setSolver(
      Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > solver) override;
 
  virtual Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > getSolver()
      const override
  {
    return solver_;
  }

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

  virtual Scalar getAlpha(const Scalar dt) const = 0;

  virtual Scalar getBeta(const Scalar dt) const = 0;

  const Thyra::SolveStatus<Scalar> solveImplicitODE(
      const Teuchos::RCP<Thyra::VectorBase<Scalar> >& x,
      const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xDot, const Scalar time,
      const Teuchos::RCP<ImplicitODEParameters<Scalar> >& p,
      const Teuchos::RCP<Thyra::VectorBase<Scalar> >& y = Teuchos::null,
      const int index                                   = -1 /* index and y are for IMEX_RK_Partition */);

  void evaluateImplicitODE(
      Teuchos::RCP<Thyra::VectorBase<Scalar> >& f,
      const Teuchos::RCP<Thyra::VectorBase<Scalar> >& x,
      const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xDot, const Scalar time,
      const Teuchos::RCP<ImplicitODEParameters<Scalar> >& p);

  virtual void setInitialGuess(
      Teuchos::RCP<const Thyra::VectorBase<Scalar> > initialGuess) override
  {
    initialGuess_        = initialGuess;
    this->isInitialized_ = false;
  }

  virtual void setZeroInitialGuess(bool zIG)
  {
    zeroInitialGuess_    = zIG;
    this->isInitialized_ = false;
  }
 
  virtual bool getZeroInitialGuess() const { return zeroInitialGuess_; }
 
  virtual Scalar getInitTimeStep(
      const Teuchos::RCP<SolutionHistory<Scalar> >& /* solutionHistory */)
      const override
  {
    return Scalar(1.0e+99);
  }



  virtual void describe(
      Teuchos::FancyOStream& out,
      const Teuchos::EVerbosityLevel verbLevel) const override;
 
  virtual bool isValidSetup(Teuchos::FancyOStream& out) const override;
 
  virtual Teuchos::RCP<const Teuchos::ParameterList> getValidParameters()
      const override;
 
  Teuchos::RCP<Teuchos::ParameterList> getValidParametersBasicImplicit() const;

  void setStepperImplicitValues(Teuchos::RCP<Teuchos::ParameterList> pl);

  void setStepperSolverValues(Teuchos::RCP<Teuchos::ParameterList> pl);

  void setSolverName(std::string i) { solverName_ = i; }
  std::string getSolverName() const { return solverName_; }
 
 protected:
  Teuchos::RCP<WrapperModelEvaluator<Scalar> > wrapperModel_;
  Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > solver_;
  Teuchos::RCP<const Thyra::VectorBase<Scalar> > initialGuess_;
  bool zeroInitialGuess_;
  std::string solverName_;
};

inline void removeStepperSolverObjects(Teuchos::ParameterList& stepperPL)
{
  if (!stepperPL.isType<std::string>("Solver Name")) return;
  const std::string solverName = stepperPL.get<std::string>("Solver Name");
  if (!stepperPL.isSublist(solverName) ||
      !stepperPL.sublist(solverName).isSublist("NOX"))
    return;
  Teuchos::ParameterList& noxPL = stepperPL.sublist(solverName).sublist("NOX");
 
  if (noxPL.isSublist("Solver Options")) {
    Teuchos::ParameterList& optionsPL = noxPL.sublist("Solver Options");
    optionsPL.remove("User Defined Pre/Post Operator", false);
    optionsPL.remove("User Defined Merit Function", false);
  }
  if (noxPL.isSublist("Thyra Group Options")) {
    Teuchos::ParameterList& groupPL = noxPL.sublist("Thyra Group Options");
    if (groupPL.isType<std::string>("Function Scaling") &&
        groupPL.get<std::string>("Function Scaling") == "User Defined")
      groupPL.set<std::string>("Function Scaling", "None");
    groupPL.remove("User Defined Scaling", false);
  }
}

inline void removeIntegratorSolverObjects(Teuchos::ParameterList& tempusPL)
{
  if (!tempusPL.isType<std::string>("Integrator Name")) return;
  const std::string integratorName =
      tempusPL.get<std::string>("Integrator Name");
  if (!tempusPL.isSublist(integratorName)) return;
  Teuchos::ParameterList& integratorPL = tempusPL.sublist(integratorName);
  if (!integratorPL.isType<std::string>("Stepper Name")) return;
  const std::string stepperName = integratorPL.get<std::string>("Stepper Name");
  if (!tempusPL.isSublist(stepperName)) return;
  removeStepperSolverObjects(tempusPL.sublist(stepperName));
}
 
}  // namespace Tempus
#endif  // Tempus_StepperImplicit_decl_hpp