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