Tempus_StepperSubcycling_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_StepperSubcycling_decl_hpp
#define Tempus_StepperSubcycling_decl_hpp

#include "Tempus_config.hpp"
#include "Tempus_StepperExplicit.hpp"
#include "Tempus_StepperSubcyclingAppAction.hpp"
#include "Tempus_IntegratorBasic.hpp"

namespace Tempus {

template <class Scalar>
class StepperSubcycling : virtual public Tempus::Stepper<Scalar> {
 public:
  StepperSubcycling();

  StepperSubcycling(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel,
      const Teuchos::RCP<IntegratorBasic<Scalar> >& integrator, bool useFSAL,
      std::string ICConsistency, bool ICConsistencyCheck,
      const Teuchos::RCP<StepperSubcyclingAppAction<Scalar> >&
          stepperSCAppAction);


  virtual void setModel(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel);

  virtual void setNonConstModel(
      const Teuchos::RCP<Thyra::ModelEvaluator<Scalar> >& appModel);

  virtual Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > getModel() const
  {
    return scIntegrator_->getStepper()->getModel();
  }

  virtual void setAppAction(Teuchos::RCP<StepperSubcyclingAppAction<Scalar> >
                                appAction = Teuchos::null);

  virtual Teuchos::RCP<StepperSubcyclingAppAction<Scalar> > getAppAction() const
  {
    return stepperSCAppAction_;
  }

  virtual void initialize();

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

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

  //  thus a no-op for explicit steppers.
  virtual void setInitialGuess(
      Teuchos::RCP<const Thyra::VectorBase<Scalar> > initial_guess);

  virtual void setSolver(
      Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > solver = Teuchos::null);

  virtual Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > getSolver() const;

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

  virtual Teuchos::RCP<Tempus::StepperState<Scalar> > getDefaultStepperState();

  virtual bool isExplicit() const;
  virtual bool isImplicit() const;
  virtual bool isExplicitImplicit() const;
  virtual bool isOneStepMethod() const;
  virtual bool isMultiStepMethod() const;

  virtual Scalar getOrder() const;
  virtual Scalar getOrderMin() const;
  virtual Scalar getOrderMax() const;
  virtual OrderODE getOrderODE() const;

  Teuchos::RCP<const Teuchos::ParameterList> getValidParameters() const;


  virtual void describe(Teuchos::FancyOStream& out,
                        const Teuchos::EVerbosityLevel verbLevel) const;


  virtual void setSubcyclingStepper(Teuchos::RCP<Stepper<Scalar> > stepper);
  virtual void setSubcyclingMinTimeStep(Scalar MinTimeStep);
  virtual void setSubcyclingInitTimeStep(Scalar InitTimeStep);
  virtual void setSubcyclingMaxTimeStep(Scalar MaxTimeStep);
  virtual void setSubcyclingMaxFailures(int MaxFailures);
  virtual void setSubcyclingMaxConsecFailures(int MaxConsecFailures);
  virtual void setSubcyclingScreenOutputIndexInterval(int i);
  virtual void setSubcyclingScreenOutputIndexList(std::string s);
  virtual void setSubcyclingTimeStepControlStrategy(
      Teuchos::RCP<TimeStepControlStrategy<Scalar> > tscs);
  virtual void setSubcyclingIntegratorObserver(
      Teuchos::RCP<IntegratorObserver<Scalar> > obs);
  virtual void setSubcyclingPrintDtChanges(bool printDtChanges);


  virtual Teuchos::RCP<const Stepper<Scalar> > getSubcyclingStepper() const;
  virtual Scalar getSubcyclingMinTimeStep() const;
  virtual Scalar getSubcyclingInitTimeStep() const;
  virtual Scalar getSubcyclingMaxTimeStep() const;
  virtual std::string getSubcyclingStepType() const;
  virtual int getSubcyclingMaxFailures() const;
  virtual int getSubcyclingMaxConsecFailures() const;
  virtual int getSubcyclingScreenOutputIndexInterval() const;
  virtual std::string getSubcyclingScreenOutputIndexList() const;
  virtual Teuchos::RCP<TimeStepControlStrategy<Scalar> >
  getSubcyclingTimeStepControlStrategy() const;
  virtual Teuchos::RCP<IntegratorObserver<Scalar> >
  getSubcyclingIntegratorObserver() const;
  virtual bool getSubcyclingPrintDtChanges() const;

 protected:
  Teuchos::RCP<StepperSubcyclingAppAction<Scalar> > stepperSCAppAction_;
  Teuchos::RCP<IntegratorBasic<Scalar> > scIntegrator_;
};

// ------------------------------------------------------------------------
template <class Scalar>
Teuchos::RCP<StepperSubcycling<Scalar> > createStepperSubcycling(
    const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model,
    Teuchos::RCP<Teuchos::ParameterList> pl);

}  // namespace Tempus

#endif  // Tempus_StepperSubcycling_decl_hpp