Tempus_SolutionHistory_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_SolutionHistory_decl_hpp
#define Tempus_SolutionHistory_decl_hpp

#include "Tempus_config.hpp"
#include "Tempus_SolutionState.hpp"
#include "Tempus_Interpolator.hpp"

namespace Tempus {

enum StorageType {
  STORAGE_TYPE_INVALID     = 0,  
  STORAGE_TYPE_KEEP_NEWEST = 1,  
  STORAGE_TYPE_UNDO        = 2,  
  STORAGE_TYPE_STATIC      = 3,  
  STORAGE_TYPE_UNLIMITED   = 4,  
};

template <class Scalar>
class SolutionHistory
  : virtual public Teuchos::Describable,
    virtual public Teuchos::VerboseObject<SolutionHistory<Scalar> > {
 public:
  SolutionHistory();

  SolutionHistory(
      std::string name,
      Teuchos::RCP<std::vector<Teuchos::RCP<SolutionState<Scalar> > > > history,
      Teuchos::RCP<Interpolator<Scalar> > interpolator, StorageType storageType,
      int storageLimit);

  ~SolutionHistory() {}


  void addState(const Teuchos::RCP<SolutionState<Scalar> >& state,
                bool doChecks = true);  // <-- Perform internal checks.

  void addWorkingState(const Teuchos::RCP<SolutionState<Scalar> >& state,
                       const bool updateTime = true);

  void removeState(const Teuchos::RCP<SolutionState<Scalar> >& state);

  void removeState(const Scalar time);

  Teuchos::RCP<SolutionState<Scalar> > findState(const Scalar time) const;

  Teuchos::RCP<SolutionState<Scalar> > interpolateState(
      const Scalar time) const;

  void interpolateState(const Scalar time,
                        SolutionState<Scalar>* state_out) const;

  void initWorkingState();

  void promoteWorkingState();

  void clear()
  {
    history_->clear();
    isInitialized_ = false;
  }

  void copy(Teuchos::RCP<const SolutionHistory<Scalar> > sh);


  std::string getName() const { return name_; }

  void setName(std::string name) { name_ = name; }

  Teuchos::RCP<std::vector<Teuchos::RCP<SolutionState<Scalar> > > > getHistory()
      const
  {
    return history_;
  }

  void setHistory(
      Teuchos::RCP<std::vector<Teuchos::RCP<SolutionState<Scalar> > > > h)
  {
    history_       = h;
    isInitialized_ = false;
  }

  Teuchos::RCP<SolutionState<Scalar> > operator[](const int i)
  {
    TEUCHOS_TEST_FOR_EXCEPTION(
        !((0 <= i) && (i < (int)history_->size())), std::out_of_range,
        "Error - SolutionHistory index is out of range.\n"
            << "    [Min, Max] = [ 0, " << history_->size() << "]\n"
            << "    index = " << i << "\n");
    return (*history_)[i];
  }

  Teuchos::RCP<const SolutionState<Scalar> > operator[](const int i) const
  {
    TEUCHOS_TEST_FOR_EXCEPTION(
        !((0 <= i) && (i < (int)history_->size())), std::out_of_range,
        "Error - SolutionHistory index is out of range.\n"
            << "    [Min, Max] = [ 0, " << history_->size() << "]\n"
            << "    index = " << i << "\n");
    return (*history_)[i];
  }

  Teuchos::RCP<SolutionState<Scalar> > getCurrentState() const
  {
    const int m = history_->size();
    Teuchos::RCP<SolutionState<Scalar> > state;
    if (m == 0)
      state = Teuchos::null;
    else if (m == 1 || workingState_ == Teuchos::null)
      state = (*history_)[m - 1];
    else if (m > 1)
      state = (*history_)[m - 2];
    return state;
  }

  Teuchos::RCP<SolutionState<Scalar> > getWorkingState(bool warn = true) const
  {
    if (workingState_ == Teuchos::null && warn) {
      Teuchos::RCP<Teuchos::FancyOStream> out = this->getOStream();
      Teuchos::OSTab ostab(out, 1, "SolutionHistory::getWorkingState()");
      *out << "Warning - WorkingState is null and likely has been promoted.  "
           << "You might want to call getCurrentState() instead.\n"
           << std::endl;
    }
    return workingState_;
  }

  int getNumStates() const { return history_->size(); }

  Scalar getCurrentTime() const { return getCurrentState()->getTime(); }

  int getCurrentIndex() const { return getCurrentState()->getIndex(); }

  void setStorageLimit(int storage_limit);

  int getStorageLimit() const { return storageLimit_; }

  void setStorageType(StorageType st);

  StorageType getStorageType() const { return storageType_; }

  void setStorageTypeString(std::string st);

  std::string getStorageTypeString() const;

  Scalar minTime() const { return (history_->front())->getTime(); }

  Scalar maxTime() const { return (history_->back())->getTime(); }

  Teuchos::RCP<SolutionState<Scalar> > getStateTimeIndexN(
      bool warn = true) const;

  Teuchos::RCP<SolutionState<Scalar> > getStateTimeIndexNM1(
      bool warn = true) const;

  Teuchos::RCP<SolutionState<Scalar> > getStateTimeIndexNM2(
      bool warn = true) const;

  Teuchos::RCP<SolutionState<Scalar> > getStateTimeIndex(
      int index, bool warn = true) const;

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

  Teuchos::RCP<Teuchos::ParameterList> getNonconstParameterList();


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


  void setInterpolator(const Teuchos::RCP<Interpolator<Scalar> >& interpolator);
  Teuchos::RCP<Interpolator<Scalar> > getNonconstInterpolator();
  Teuchos::RCP<const Interpolator<Scalar> > getInterpolator() const;
  Teuchos::RCP<Interpolator<Scalar> > unSetInterpolator();

  void printHistory(std::string verb = "low") const;

  void initialize() const;

  bool isInitialized() { return isInitialized_; }

 protected:
  std::string name_;
  Teuchos::RCP<std::vector<Teuchos::RCP<SolutionState<Scalar> > > > history_;
  Teuchos::RCP<Interpolator<Scalar> > interpolator_;
  StorageType storageType_;
  int storageLimit_;

  Teuchos::RCP<SolutionState<Scalar> >
      workingState_;  

  mutable bool isInitialized_;  
};

template <class Scalar>
Teuchos::RCP<SolutionHistory<Scalar> > createSolutionHistory();

template <class Scalar>
Teuchos::RCP<SolutionHistory<Scalar> > createSolutionHistoryPL(
    Teuchos::RCP<Teuchos::ParameterList> pList);

template <class Scalar>
Teuchos::RCP<SolutionHistory<Scalar> > createSolutionHistoryState(
    const Teuchos::RCP<SolutionState<Scalar> >& state);

template <class Scalar>
Teuchos::RCP<SolutionHistory<Scalar> > createSolutionHistoryME(
    const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model);

}  // namespace Tempus

#endif  // Tempus_SolutionHistory_decl_hpp