Tempus_SolutionHistory_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_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