Tempus_StepperOperatorSplit_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_StepperOperatorSplit_decl_hpp
#define Tempus_StepperOperatorSplit_decl_hpp
 
#include "Tempus_config.hpp"
#include "Tempus_Stepper.hpp"
#include "Tempus_StepperOperatorSplitAppAction.hpp"
 
namespace Tempus {
 
template <class Scalar>
class StepperOperatorSplit : virtual public Tempus::Stepper<Scalar> {
 public:
  StepperOperatorSplit();
 
  StepperOperatorSplit(
      std::vector<Teuchos::RCP<const Thyra::ModelEvaluator<Scalar>>> appModels,
      std::vector<Teuchos::RCP<Stepper<Scalar>>> subStepperList, bool useFSAL,
      std::string ICConsistency, bool ICConsistencyCheck, int order,
      int orderMin, int orderMax,
      const Teuchos::RCP<StepperOperatorSplitAppAction<Scalar>>&
          stepperOSAppAction);
 
 
  virtual void setModel(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar>>& appModel);
 
  virtual Teuchos::RCP<const Thyra::ModelEvaluator<Scalar>> getModel() const;
 
  virtual void setSolver(
      Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar>> solver);
 
  virtual Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar>> getSolver() const
  {
    return Teuchos::null;
  }
 
  virtual void setAppAction(
      Teuchos::RCP<StepperOperatorSplitAppAction<Scalar>> appAction);
 
  virtual Teuchos::RCP<StepperOperatorSplitAppAction<Scalar>> getAppAction()
      const
  {
    return stepperOSAppAction_;
  }
 
  virtual void setTempState(Teuchos::RCP<Tempus::SolutionState<Scalar>> state)
  {
    tempState_ = state;
  }
 
  virtual void initialize();
 
  virtual void setInitialConditions(
      const Teuchos::RCP<SolutionHistory<Scalar>>& solutionHistory);
 
  virtual void takeStep(
      const Teuchos::RCP<SolutionHistory<Scalar>>& solutionHistory);
 
  virtual void setInitialGuess(
      Teuchos::RCP<const Thyra::VectorBase<Scalar>> /* initial_guess */)
  {
  }
 
  virtual Teuchos::RCP<Tempus::StepperState<Scalar>> getDefaultStepperState();
  virtual Scalar getOrder() const { return order_; }
  virtual Scalar getOrderMin() const { return orderMin_; }
  virtual Scalar getOrderMax() const { return orderMax_; }
 
  virtual Scalar getInitTimeStep(
      const Teuchos::RCP<SolutionHistory<Scalar>>& /* solutionHistory */) const
  {
    return Scalar(1.0e+99);
  }
  virtual void setOrder(Scalar o) { order_ = o; }
  virtual void setOrderMin(Scalar o) { orderMin_ = o; }
  virtual void setOrderMax(Scalar o) { orderMax_ = o; }
 
  virtual bool isExplicit() const
  {
    bool isExplicit = false;
    typename std::vector<Teuchos::RCP<Stepper<Scalar>>>::const_iterator
        subStepperIter = subStepperList_.begin();
    for (; subStepperIter < subStepperList_.end(); subStepperIter++) {
      if ((*subStepperIter)->isExplicit()) isExplicit = true;
    }
    return isExplicit;
  }
  virtual bool isImplicit() const
  {
    bool isImplicit = false;
    typename std::vector<Teuchos::RCP<Stepper<Scalar>>>::const_iterator
        subStepperIter = subStepperList_.begin();
    for (; subStepperIter < subStepperList_.end(); subStepperIter++) {
      if ((*subStepperIter)->isImplicit()) isImplicit = true;
    }
    return isImplicit;
  }
  virtual bool isExplicitImplicit() const
  {
    return isExplicit() && isImplicit();
  }
  virtual bool isOneStepMethod() const
  {
    bool isOneStepMethod = true;
    typename std::vector<Teuchos::RCP<Stepper<Scalar>>>::const_iterator
        subStepperIter = subStepperList_.begin();
    for (; subStepperIter < subStepperList_.end(); subStepperIter++) {
      if (!(*subStepperIter)->isOneStepMethod()) isOneStepMethod = false;
    }
    return isOneStepMethod;
  }
  virtual bool isMultiStepMethod() const { return !isOneStepMethod(); }
  virtual void setUseFSAL(bool a)
  {
    this->useFSAL_       = a;
    this->isInitialized_ = false;
  }
  virtual OrderODE getOrderODE() const { return FIRST_ORDER_ODE; }
 
  Teuchos::RCP<const Teuchos::ParameterList> getValidParameters() const;
 
  void createSubSteppers(
      std::vector<Teuchos::RCP<const Thyra::ModelEvaluator<Scalar>>> appModels,
      Teuchos::RCP<Teuchos::ParameterList> pl);
 
 
  virtual void describe(Teuchos::FancyOStream& out,
                        const Teuchos::EVerbosityLevel verbLevel) const;
 
  virtual bool isValidSetup(Teuchos::FancyOStream& out) const;
 
  virtual std::vector<Teuchos::RCP<Stepper<Scalar>>> getStepperList() const
  {
    return subStepperList_;
  }
  virtual void setStepperList(std::vector<Teuchos::RCP<Stepper<Scalar>>> sl)
  {
    subStepperList_ = sl;
  }
 
  virtual void addStepper(Teuchos::RCP<Stepper<Scalar>> stepper,
                          bool useFSAL = false);
 
  virtual void setSubStepperList(
      std::vector<Teuchos::RCP<Stepper<Scalar>>> subStepperList);
 
  virtual void clearSubStepperList() { subStepperList_.clear(); }
 
  virtual void setModels(
      std::vector<Teuchos::RCP<const Thyra::ModelEvaluator<Scalar>>> appModels);
 
 protected:
  Scalar order_;
  Scalar orderMin_;
  Scalar orderMax_;
 
  std::vector<Teuchos::RCP<Stepper<Scalar>>> subStepperList_;
  Teuchos::RCP<SolutionHistory<Scalar>> OpSpSolnHistory_;
  Teuchos::RCP<SolutionState<Scalar>> tempState_;
  Teuchos::RCP<StepperOperatorSplitAppAction<Scalar>> stepperOSAppAction_;
};
 
// ------------------------------------------------------------------------
template <class Scalar>
Teuchos::RCP<StepperOperatorSplit<Scalar>> createStepperOperatorSplit(
    std::vector<Teuchos::RCP<const Thyra::ModelEvaluator<Scalar>>> appModels,
    Teuchos::RCP<Teuchos::ParameterList> pl);
 
}  // namespace Tempus
 
#endif  // Tempus_StepperOperatorSplit_decl_hpp