Tempus_SolutionState_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_SolutionState_decl_hpp
#define Tempus_SolutionState_decl_hpp

#include "Teuchos_VerboseObject.hpp"
#include "Teuchos_Describable.hpp"

#include "Thyra_VectorBase.hpp"
#include "Thyra_ModelEvaluator.hpp"

#include "Tempus_config.hpp"
#include "Tempus_SolutionStateMetaData.hpp"
#include "Tempus_StepperState.hpp"
#include "Tempus_PhysicsState.hpp"

namespace Tempus {

template <class Scalar>
class SolutionState
  : public Teuchos::Describable,
    public Teuchos::VerboseObject<Tempus::SolutionState<Scalar> > {
 public:
  SolutionState();

  SolutionState(const Teuchos::RCP<SolutionStateMetaData<Scalar> > ssmd,
                const Teuchos::RCP<Thyra::VectorBase<Scalar> >& x,
                const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xdot,
                const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xdotdot,
                const Teuchos::RCP<StepperState<Scalar> >& stepperState,
                const Teuchos::RCP<PhysicsState<Scalar> >& physicsState);

  SolutionState(const Teuchos::RCP<const SolutionStateMetaData<Scalar> > ssmd,
                const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& x,
                const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& xdot,
                const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& xdotdot,
                const Teuchos::RCP<const StepperState<Scalar> >& stepperState,
                const Teuchos::RCP<const PhysicsState<Scalar> >& physicsState);

  SolutionState(const SolutionState<Scalar>& ss);

  virtual Teuchos::RCP<SolutionState<Scalar> > clone() const;

  virtual void copy(const Teuchos::RCP<const SolutionState<Scalar> >& ss);

  virtual void copySolutionData(
      const Teuchos::RCP<const SolutionState<Scalar> >& s);

  virtual ~SolutionState() {}


  virtual Teuchos::RCP<const SolutionStateMetaData<Scalar> > getMetaData() const
  {
    return metaData_;
  }
  virtual Teuchos::RCP<SolutionStateMetaData<Scalar> > getMetaData()
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    return metaData_nc_;
  }

  virtual Scalar getTime() const { return metaData_->getTime(); }
  virtual int getIndex() const { return metaData_->getIStep(); }
  virtual Scalar getTimeStep() const { return metaData_->getDt(); }
  virtual Scalar getErrorAbs() const { return metaData_->getErrorAbs(); }
  virtual Scalar getErrorRel() const { return metaData_->getErrorRel(); }
  virtual Scalar getErrorRelNm1() const { return metaData_->getErrorRelNm1(); }
  virtual Scalar getErrorRelNm2() const { return metaData_->getErrorRelNm2(); }
  virtual int getOrder() const { return metaData_->getOrder(); }
  virtual int getNFailures() const { return metaData_->getNFailures(); }
  virtual int getNRunningFailures() const
  {
    return metaData_->getNRunningFailures();
  }
  virtual int getNConsecutiveFailures() const
  {
    return metaData_->getNConsecutiveFailures();
  }
  virtual Scalar getTolAbs() const { return metaData_->getTolAbs(); }
  virtual Scalar getTolRel() const { return metaData_->getTolRel(); }
  virtual Scalar getXNormL2() const { return metaData_->getXNormL2(); }
  virtual Scalar getDxNormL2Abs() const { return metaData_->getDxNormL2Abs(); }
  virtual Scalar getDxNormL2Rel() const { return metaData_->getDxNormL2Rel(); }
  virtual bool getComputeNorms() const { return metaData_->getComputeNorms(); }
  virtual Status getSolutionStatus() const
  {
    return metaData_->getSolutionStatus();
  }
  virtual bool getOutput() const { return metaData_->getOutput(); }
  virtual bool getOutputScreen() const { return metaData_->getOutputScreen(); }
  virtual bool getIsSynced() const { return metaData_->getIsSynced(); }
  virtual bool getIsInterpolated() const
  {
    return metaData_->getIsInterpolated();
  }
  virtual bool getAccuracy() const { return metaData_->getAccuracy(); }


  virtual void setMetaData(
      Teuchos::RCP<const SolutionStateMetaData<Scalar> > md)
  {
    metaData_    = md;
    metaData_nc_ = Teuchos::null;
  }
  virtual void setMetaData(Teuchos::RCP<SolutionStateMetaData<Scalar> > md)
  {
    metaData_nc_ = md;
    metaData_    = metaData_nc_;
  }

  virtual void setTime(Scalar time)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setTime(time);
  }
  virtual void setIndex(Scalar index)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setIStep(index);
  }
  virtual void setTimeStep(Scalar dt)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setDt(dt);
  }
  virtual void setErrorAbs(Scalar errorAbs)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setErrorAbs(errorAbs);
  }
  virtual void setErrorRel(Scalar errorRel)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setErrorRel(errorRel);
  }
  virtual void setOrder(int order)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setOrder(order);
  }

  virtual void setNFailures(int nFailures)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setNFailures(nFailures);
  }
  virtual void setNRunningFailures(int nFailures)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setNRunningFailures(nFailures);
  }
  virtual void setNConsecutiveFailures(int nConsecutiveFailures)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setNConsecutiveFailures(nConsecutiveFailures);
  }
  virtual void setTolRel(Scalar tolRel)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setTolRel(tolRel);
  }
  virtual void setTolAbs(Scalar tolAbs)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setTolAbs(tolAbs);
  }

  virtual void setXNormL2(Scalar xNormL2)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setXNormL2(xNormL2);
  }
  virtual void setDxNormL2Rel(Scalar dxNormL2Rel)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setDxNormL2Rel(dxNormL2Rel);
  }
  virtual void setDxNormL2Abs(Scalar dxNormL2Abs)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setDxNormL2Abs(dxNormL2Abs);
  }
  virtual void setComputeNorms(bool computeNorms)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setComputeNorms(computeNorms);
  }

  virtual void setSolutionStatus(Status s)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setSolutionStatus(s);
  }
  virtual void setSolutionStatus(const Thyra::SolveStatus<Scalar> sStatus)
  {
    if (sStatus.solveStatus == Thyra::SOLVE_STATUS_CONVERGED)
      metaData_nc_->setSolutionStatus(Status::PASSED);
    else
      metaData_nc_->setSolutionStatus(Status::FAILED);
  }

  virtual void setOutput(bool output)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setOutput(output);
  }
  virtual void setOutputScreen(bool output)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setOutputScreen(output);
  }
  virtual void setIsSynced(bool isSynced)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setIsSynced(isSynced);
  }
  virtual void setIsInterpolated(bool isInterpolated)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setIsInterpolated(isInterpolated);
  }
  virtual void setAccuracy(bool accuracy)
  {
    TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
    metaData_nc_->setAccuracy(accuracy);
  }


  virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getX()
  {
    TEUCHOS_ASSERT(x_nc_ != Teuchos::null);
    return x_nc_;
  }
  virtual Teuchos::RCP<const Thyra::VectorBase<Scalar> > getX() const
  {
    return x_;
  }
  virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getXDot()
  {
    return xdot_nc_;
  }
  virtual Teuchos::RCP<const Thyra::VectorBase<Scalar> > getXDot() const
  {
    return xdot_;
  }
  virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getXDotDot()
  {
    return xdotdot_nc_;
  }
  virtual Teuchos::RCP<const Thyra::VectorBase<Scalar> > getXDotDot() const
  {
    return xdotdot_;
  }

  virtual Teuchos::RCP<StepperState<Scalar> > getStepperState()
  {
    TEUCHOS_ASSERT(stepperState_nc_ != Teuchos::null);
    return stepperState_nc_;
  }
  virtual Teuchos::RCP<const StepperState<Scalar> > getStepperState() const
  {
    return stepperState_;
  }

  virtual Teuchos::RCP<PhysicsState<Scalar> > getPhysicsState()
  {
    return physicsState_nc_;
  }
  virtual Teuchos::RCP<const PhysicsState<Scalar> > getPhysicsState() const
  {
    return physicsState_;
  }


  virtual void setX(Teuchos::RCP<Thyra::VectorBase<Scalar> > x)
  {
    x_nc_ = x;
    x_    = x;
  }
  virtual void setX(Teuchos::RCP<const Thyra::VectorBase<Scalar> > x)
  {
    x_nc_ = Teuchos::null;
    x_    = x;
  }
  virtual void setXDot(Teuchos::RCP<Thyra::VectorBase<Scalar> > xdot)
  {
    xdot_nc_ = xdot;
    xdot_    = xdot;
  }
  virtual void setXDot(Teuchos::RCP<const Thyra::VectorBase<Scalar> > xdot)
  {
    xdot_nc_ = Teuchos::null;
    xdot_    = xdot;
  }
  virtual void setXDotDot(Teuchos::RCP<Thyra::VectorBase<Scalar> > xdotdot)
  {
    xdotdot_nc_ = xdotdot;
    xdotdot_    = xdotdot;
  }
  virtual void setXDotDot(
      Teuchos::RCP<const Thyra::VectorBase<Scalar> > xdotdot)
  {
    xdotdot_nc_ = Teuchos::null;
    xdotdot_    = xdotdot;
  }

  virtual void setStepperState(Teuchos::RCP<StepperState<Scalar> >& ss)
  {
    stepperState_nc_ = ss;
    stepperState_    = ss;
  }
  virtual void setStepperState(const Teuchos::RCP<StepperState<Scalar> >& ss)
  {
    stepperState_nc_ = Teuchos::null;
    stepperState_    = ss;
  }

  virtual void setPhysicsState(Teuchos::RCP<PhysicsState<Scalar> >& ps)
  {
    physicsState_nc_ = ps;
    physicsState_    = ps;
  }
  virtual void setPhysicsState(const Teuchos::RCP<PhysicsState<Scalar> >& ps)
  {
    physicsState_nc_ = Teuchos::null;
    physicsState_    = ps;
  }


  bool operator<(const SolutionState<Scalar>& ss) const;

  bool operator<=(const SolutionState<Scalar>& ss) const;

  bool operator<(const Scalar& t) const;

  bool operator<=(const Scalar& t) const;

  bool operator>(const SolutionState<Scalar>& ss) const;

  bool operator>=(const SolutionState<Scalar>& ss) const;

  bool operator>(const Scalar& t) const;

  bool operator>=(const Scalar& t) const;

  bool operator==(const SolutionState<Scalar>& ss) const;

  bool operator==(const Scalar& t) const;


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

  virtual void computeNorms(
      const Teuchos::RCP<const SolutionState<Scalar> >& ssIn = Teuchos::null);

 private:
  // Member Data

  Teuchos::RCP<const SolutionStateMetaData<Scalar> > metaData_;
  Teuchos::RCP<SolutionStateMetaData<Scalar> > metaData_nc_;

  Teuchos::RCP<const Thyra::VectorBase<Scalar> > x_;
  Teuchos::RCP<Thyra::VectorBase<Scalar> > x_nc_;

  Teuchos::RCP<const Thyra::VectorBase<Scalar> > xdot_;
  Teuchos::RCP<Thyra::VectorBase<Scalar> > xdot_nc_;

  Teuchos::RCP<const Thyra::VectorBase<Scalar> > xdotdot_;
  Teuchos::RCP<Thyra::VectorBase<Scalar> > xdotdot_nc_;

  Teuchos::RCP<const StepperState<Scalar> > stepperState_;
  Teuchos::RCP<StepperState<Scalar> > stepperState_nc_;

  Teuchos::RCP<const PhysicsState<Scalar> > physicsState_;
  Teuchos::RCP<PhysicsState<Scalar> > physicsState_nc_;
};

template <class Scalar>
Teuchos::RCP<SolutionState<Scalar> > createSolutionStateX(
    const Teuchos::RCP<Thyra::VectorBase<Scalar> >& x,
    const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xdot    = Teuchos::null,
    const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xdotdot = Teuchos::null);

template <class Scalar>
Teuchos::RCP<SolutionState<Scalar> > createSolutionStateX(
    const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& x,
    const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& xdot = Teuchos::null,
    const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& xdotdot =
        Teuchos::null);

template <class Scalar>
Teuchos::RCP<SolutionState<Scalar> > createSolutionStateME(
    const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model,
    const Teuchos::RCP<StepperState<Scalar> >& stepperState = Teuchos::null,
    const Teuchos::RCP<PhysicsState<Scalar> >& physicsState = Teuchos::null);

}  // namespace Tempus

#endif  // Tempus_SolutionState_decl_hpp