Tempus_WrapperModelEvaluatorBasic_impl.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_WrapperModelEvaluatorBasic_impl_hpp
#define Tempus_WrapperModelEvaluatorBasic_impl_hpp
 
namespace Tempus {
 
 
template <typename Scalar>
Thyra::ModelEvaluatorBase::InArgs<Scalar>
WrapperModelEvaluatorBasic<Scalar>::
createInArgs() const
{
  typedef Thyra::ModelEvaluatorBase MEB;
  //MEB::InArgsSetup<Scalar> inArgs(appModel_->createInArgs());
  MEB::InArgsSetup<Scalar> inArgs(appModel_->getNominalValues());
 
  inArgs.setModelEvalDescription(this->description());
  return std::move(inArgs);
}
 
 
template <typename Scalar>
Thyra::ModelEvaluatorBase::OutArgs<Scalar>
WrapperModelEvaluatorBasic<Scalar>::
createOutArgsImpl() const
{
  typedef Thyra::ModelEvaluatorBase MEB;
  MEB::OutArgsSetup<Scalar> outArgs(appModel_->createOutArgs());
  outArgs.setModelEvalDescription(this->description());
  return std::move(outArgs);
}
 
 
template <typename Scalar>
void
WrapperModelEvaluatorBasic<Scalar>::
evalModelImpl(const Thyra::ModelEvaluatorBase::InArgs<Scalar>  &inArgs,
              const Thyra::ModelEvaluatorBase::OutArgs<Scalar> &outArgs) const
{
  using Teuchos::RCP;
 
  typedef Thyra::ModelEvaluatorBase MEB;
  MEB::InArgs<Scalar>  appInArgs (wrapperInArgs_);
  MEB::OutArgs<Scalar> appOutArgs(wrapperOutArgs_);
 
  // Setup input and output arguments for application ME
  switch (evaluationType_)
  {
    case EVALUATE_RESIDUAL: {
 
      // Setup input arguments
      appInArgs.set_x    (inArgs.get_x()    );
      appInArgs.set_x_dot(inArgs.get_x_dot());
 
      // Setup output arguments
      appOutArgs.set_f(outArgs.get_f());
 
      break;
    }
    case SOLVE_FOR_X: {
 
      // This is the normal solution scheme where we are solving for x,
      // and xDot is dependent on x through the definition of the time
      // derivative for the Stepper.
 
      // Setup input arguments
      RCP<const Thyra::VectorBase<Scalar> > x = inArgs.get_x();
      appInArgs.set_x(x);         // x is from solver.
      RCP<Thyra::VectorBase<Scalar> > xDot =
        Teuchos::rcp_const_cast<Thyra::VectorBase<Scalar> >(
          appInArgs.get_x_dot()); // xDot is from the Stepper
      timeDer_->compute(x, xDot);
      appInArgs.set_x_dot(xDot);
 
      // Setup output arguments
      // Note: For the use that Tempus does of this class, these three args
      //       *should* be enough. However, keep in mind that it *may* be
      //       necessary to add more outArgs in the future. The idea would
      //       be the same: if the underlying model supports the arg, then
      //       set it in the appOutArgs.
      appOutArgs.set_f(outArgs.get_f());
      appOutArgs.set_W_op(outArgs.get_W_op());
      if (outArgs.supports(MEB::OUT_ARG_W_prec)) {
        appOutArgs.set_W_prec(outArgs.get_W_prec());
      }
 
      break;
    }
 
    case SOLVE_FOR_XDOT_CONST_X: {
 
      // This solution scheme is solving for xDot while keeping x constant.
      // This is similar to evaluating an explicit ODE, xDot = f(x,t).  The
      // upside is the application does not need to write f(x,t) or worry
      // about inverting a mass matrix.  This solution scheme is mostly
      // used for initial conditions to make the x and xDot consistent
      // with the governing equations.
 
      // Setup input arguments
      appInArgs.set_x(wrapperInArgs_.get_x());  // x is from the Stepper.
      appInArgs.set_x_dot(inArgs.get_x());      // xDot is from the solver.
 
      // Setup output arguments
      appOutArgs.set_f(outArgs.get_f());
      appOutArgs.set_W_op(outArgs.get_W_op());
      if (outArgs.supports(MEB::OUT_ARG_W_prec)) {
        appOutArgs.set_W_prec(outArgs.get_W_prec());
      }
 
      break;
    }
 
    default: {
      TEUCHOS_TEST_FOR_EXCEPT("Invalid EVALUATION_TYPE!");
    }
  }
 
  for (int i=0; i<appModel_->Np(); ++i) {
    if (inArgs.get_p(i) != Teuchos::null)
      appInArgs.set_p(i, inArgs.get_p(i));
  }
 
  appModel_->evalModel(appInArgs, appOutArgs);
}
 
 
} // namespace Tempus
 
#endif  // Tempus_WrapperModelEvaluatorBasic_impl_hpp