Tempus_WrapperModelEvaluatorSecondOrder_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_WrapperModelEvaluatorSecondOrder_decl_hpp
#define Tempus_WrapperModelEvaluatorSecondOrder_decl_hpp

#include <functional>
#include "Tempus_config.hpp"
#include "Tempus_WrapperModelEvaluator.hpp"
#include "Thyra_VectorBase.hpp"


//#define VERBOSE_DEBUG_OUTPUT

namespace Tempus {

template <typename Scalar>
class WrapperModelEvaluatorSecondOrder
 : public Tempus::WrapperModelEvaluator<Scalar>
{
public:
  typedef Thyra::VectorBase<Scalar>  Vector;

  WrapperModelEvaluatorSecondOrder(
    const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel, const std::string schemeName)
    : appModel_(appModel),
      out_(Teuchos::VerboseObjectBase::getDefaultOStream())
  {
#ifdef VERBOSE_DEBUG_OUTPUT
    *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
    *out_ << "    schemeName = " << schemeName << "\n";
#endif
    if (schemeName == "Newmark Implicit a-Form" || schemeName == "HHT-Alpha") {
      schemeType_ = NEWMARK_IMPLICIT_AFORM;
    }
    else if (schemeName == "Newmark Implicit d-Form") {
      schemeType_ = NEWMARK_IMPLICIT_DFORM;
    }
    else {
       TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
       "Error: WrapperModelEvaluatorSecondOrder called with unsopported schemeName = " << schemeName
       <<"!  Supported schemeNames are: 'Newmark Implicit a-Form' and 'HHT-Alpha'.\n");
    }
  }

  void setAppModel(
    const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > & me)
  {
#ifdef VERBOSE_DEBUG_OUTPUT
    *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
#endif
    appModel_ = me;
  }

  Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > getAppModel() const
  {
#ifdef VERBOSE_DEBUG_OUTPUT
    *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
#endif
    return appModel_;
  }

  void initializeNewmark(Teuchos::RCP<const Vector> v_pred,
                         Teuchos::RCP<const Vector> d_pred, Scalar delta_t,
                         Scalar t, Scalar beta, Scalar gamma)
  {
#ifdef VERBOSE_DEBUG_OUTPUT
    *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
#endif
    v_pred_ = v_pred; d_pred_ = d_pred;
    delta_t_ = delta_t; t_ = t; beta_ = beta; gamma_ = gamma;
  }


    Teuchos::RCP<Thyra::LinearOpBase<Scalar> > create_W_op() const
    {
#ifdef VERBOSE_DEBUG_OUTPUT
     *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
#endif
      return appModel_->create_W_op();
    }

    Teuchos::RCP<const Thyra::LinearOpWithSolveFactoryBase<Scalar> >
    get_W_factory() const
    {
#ifdef VERBOSE_DEBUG_OUTPUT
      *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
#endif
      return appModel_->get_W_factory();
    }

    Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_f_space() const
    {
#ifdef VERBOSE_DEBUG_OUTPUT
      *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
#endif
      return appModel_->get_f_space();
    }

    Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_p_space(int p) const
    {
#ifdef VERBOSE_DEBUG_OUTPUT
      *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
#endif
      return appModel_->get_p_space(p);
    }

    Teuchos::RCP<const Teuchos::Array<std::string> > get_p_names(int p) const
    {
#ifdef VERBOSE_DEBUG_OUTPUT
      *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
#endif
      return appModel_->get_p_names(p);
    }

    Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_x_space() const
    {
#ifdef VERBOSE_DEBUG_OUTPUT
      *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
#endif
      return appModel_->get_x_space();
    }

    Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_g_space(int i) const
    { return appModel_->get_g_space(i); }

    Thyra::ModelEvaluatorBase::InArgs<Scalar> getNominalValues() const
    {
#ifdef VERBOSE_DEBUG_OUTPUT
      *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
#endif
      return appModel_->getNominalValues();
    }

    virtual void setInArgs(Thyra::ModelEvaluatorBase::InArgs<Scalar> inArgs)
    { wrapperInArgs_.setArgs(inArgs); }

    virtual Thyra::ModelEvaluatorBase::InArgs<Scalar> getInArgs()
    { return wrapperInArgs_; }

    virtual void setOutArgs(Thyra::ModelEvaluatorBase::OutArgs<Scalar> outArgs)
    { wrapperOutArgs_.setArgs(outArgs); }

    virtual Thyra::ModelEvaluatorBase::OutArgs<Scalar> getOutArgs()
    { return wrapperOutArgs_; }

    virtual void setForSolve(Teuchos::RCP<TimeDerivative<Scalar> > timeDer,
      Thyra::ModelEvaluatorBase::InArgs<Scalar>   inArgs,
      Thyra::ModelEvaluatorBase::OutArgs<Scalar>  outArgs,
      EVALUATION_TYPE /* evaluationType */ = SOLVE_FOR_X)
    {
      timeDer_ = timeDer;
      wrapperInArgs_.setArgs(inArgs);
      wrapperOutArgs_.setArgs(outArgs);
    }

    Thyra::ModelEvaluatorBase::InArgs<Scalar> createInArgs() const;
    Thyra::ModelEvaluatorBase::OutArgs<Scalar> createOutArgsImpl() const;

    void evalModelImpl(
              const Thyra::ModelEvaluatorBase::InArgs<Scalar>  &inArgs,
              const Thyra::ModelEvaluatorBase::OutArgs<Scalar> &outArgs) const;

  enum SCHEME_TYPE {NEWMARK_IMPLICIT_AFORM, NEWMARK_IMPLICIT_DFORM};

private:

  WrapperModelEvaluatorSecondOrder();

private:

  Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > appModel_;
  Scalar t_;
  Scalar gamma_;
  Scalar beta_;
  Scalar delta_t_;
  Teuchos::RCP<const Vector> d_pred_;
  Teuchos::RCP<const Vector> v_pred_;
  Teuchos::RCP<Teuchos::FancyOStream> out_;
  SCHEME_TYPE schemeType_;

  Teuchos::RCP<TimeDerivative<Scalar> >              timeDer_;
  Thyra::ModelEvaluatorBase::InArgs<Scalar>          wrapperInArgs_;
  Thyra::ModelEvaluatorBase::OutArgs<Scalar>         wrapperOutArgs_;

};

} // namespace Tempus

#endif // Tempus_WrapperModelEvaluatorSecondOrder_hpp