Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_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_ModelEvaluatorPairPartIMEX_StaggeredFSA_impl_hpp
#define Tempus_ModelEvaluatorPairPartIMEX_StaggeredFSA_impl_hpp

#include "Thyra_VectorStdOps.hpp"
#include "Thyra_MultiVectorStdOps.hpp"

namespace Tempus {

template <typename Scalar>
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA(
  const Teuchos::RCP<const WrapperModelEvaluatorPairPartIMEX_Basic<Scalar> >& forwardModel,
  const Teuchos::RCP<const Teuchos::ParameterList>& pList) :
  forwardModel_(forwardModel),
  use_dfdp_as_tangent_(false),
  y_tangent_index_(3)
{
  using Teuchos::RCP;
  using Teuchos::rcp;
  using Thyra::multiVectorProductVectorSpace;

  RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
  if (pList != Teuchos::null)
    *pl = *pList;
  pl->validateParametersAndSetDefaults(*this->getValidParameters());
  use_dfdp_as_tangent_ = pl->get<bool>("Use DfDp as Tangent");
  y_tangent_index_ = pl->get<int>("Sensitivity Y Tangent Index");
  pl->remove("Sensitivity Y Tangent Index");

  appExplicitModel_ = forwardModel_->getExplicitModel();
  appImplicitModel_ = forwardModel_->getImplicitModel();
  fsaExplicitModel_ = rcp(new FSAME(appExplicitModel_, pl));
  fsaImplicitModel_ = rcp(new FSAME(appImplicitModel_, pl));

  const int y_param_index = forwardModel_->getParameterIndex();
  const int sens_param_index = pl->get<int>("Sensitivity Parameter Index");
  const int num_sens_param =
    appImplicitModel_->get_p_space(sens_param_index)->dim();
  RCP<const Thyra::VectorSpaceBase<Scalar> > explicit_y_space =
    appImplicitModel_->get_p_space(y_param_index);
  RCP<const Thyra::VectorSpaceBase<Scalar> > implicit_x_space =
    appImplicitModel_->get_x_space();
  explicit_dydp_prod_space_ =
    multiVectorProductVectorSpace(explicit_y_space, num_sens_param);
  imex_dxdp_prod_space_ =
    multiVectorProductVectorSpace(implicit_x_space, num_sens_param);

  Base::setup(fsaExplicitModel_, fsaImplicitModel_,
              forwardModel_->getNumExplicitOnlyBlocks(),
              y_param_index);
}

template <typename Scalar>
void
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
initialize()
{
  using Teuchos::RCP;
  using Teuchos::rcp_dynamic_cast;

  this->useImplicitModel_ = true;
  this->wrapperImplicitInArgs_  = this->createInArgs();
  this->wrapperImplicitOutArgs_ = this->createOutArgs();
  this->useImplicitModel_ = false;

  RCP<const Thyra::VectorBase<Scalar> > z =
    this->explicitModel_->getNominalValues().get_x();

  // A Thyra::VectorSpace requirement
  TEUCHOS_TEST_FOR_EXCEPTION( !(getIMEXVector(z)->space()->isCompatible(
                                  *(this->implicitModel_->get_x_space()))),
    std::logic_error,
    "Error - WrapperModelEvaluatorPairIMEX_StaggeredFSA::initialize()\n"
    "  Explicit and Implicit vector x spaces are incompatible!\n"
    "  Explicit vector x space = " << *(getIMEXVector(z)->space()) << "\n"
    "  Implicit vector x space = " << *(this->implicitModel_->get_x_space()) <<
    "\n");

  // Valid number of blocks?
  const RCP<const DMVPV> z_dmvpv = rcp_dynamic_cast<const DMVPV>(z,true);
  const RCP<const Thyra::MultiVectorBase<Scalar> > z_mv =
    z_dmvpv->getMultiVector();
  RCP<const PMVB> zPVector = rcp_dynamic_cast<const PMVB>(z_mv);
   TEUCHOS_TEST_FOR_EXCEPTION( zPVector == Teuchos::null, std::logic_error,
    "Error - WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::initialize()\n"
    "  was given a VectorBase that could not be cast to a\n"
    "  ProductVectorBase!\n");

  int numBlocks = zPVector->productSpace()->numBlocks();

  TEUCHOS_TEST_FOR_EXCEPTION( !(0 <= this->numExplicitOnlyBlocks_ and
                                this->numExplicitOnlyBlocks_ < numBlocks),
    std::logic_error,
    "Error - WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::initialize()\n"
    "Invalid number of explicit-only blocks = " <<
    this->numExplicitOnlyBlocks_ << "\n"
    "Should be in the interval [0, numBlocks) = [0, " << numBlocks << ")\n");
}

template <typename Scalar>
Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> >
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
get_p_space(int i) const
{
  if (this->useImplicitModel_) {
    if (i == this->parameterIndex_)
      return explicit_dydp_prod_space_;
    else
      return appImplicitModel_->get_p_space(i);
  }

  return appExplicitModel_->get_p_space(i);
}

template <typename Scalar>
Teuchos::RCP<Thyra::VectorBase<Scalar> >
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
getIMEXVector(const Teuchos::RCP<Thyra::VectorBase<Scalar> > & full) const
{
  using Teuchos::RCP;
  using Teuchos::rcp_dynamic_cast;
  using Thyra::MultiVectorBase;
  using Thyra::VectorBase;
  using Thyra::multiVectorProductVector;

  // StaggeredFSA ME stores vectors as DMVPV's.  To extract the implicit
  // part of the vector, cast it to DMVPV,  extract the multi-vector,
  // cast it to a product multi-vector, extract the IMEX block, then
  // create a DMVPV from it.

  if(full == Teuchos::null)
    return Teuchos::null;

  if (this->numExplicitOnlyBlocks_==0)
    return full;

  const RCP<DMVPV> full_dmvpv = rcp_dynamic_cast<DMVPV>(full,true);
  const RCP<MultiVectorBase<Scalar> > full_mv =
    full_dmvpv->getNonconstMultiVector();
  const RCP<PMVB> blk_full_mv = rcp_dynamic_cast<PMVB>(full_mv,true);

  // special case where the implicit terms are not blocked
  const int numBlocks = blk_full_mv->productSpace()->numBlocks();
  const int numExplicitBlocks = this->numExplicitOnlyBlocks_;
  if (numBlocks == numExplicitBlocks+1) {
    const RCP<MultiVectorBase<Scalar> > imex_mv =
      blk_full_mv->getNonconstMultiVectorBlock(numExplicitBlocks);
    return multiVectorProductVector(imex_dxdp_prod_space_, imex_mv);
  }

  // Not supposed to get here, apparently
  TEUCHOS_ASSERT(false);
  return Teuchos::null;
}

template <typename Scalar>
Teuchos::RCP<const Thyra::VectorBase<Scalar> >
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
getIMEXVector(const Teuchos::RCP<const Thyra::VectorBase<Scalar> > & full) const
{
  using Teuchos::RCP;
  using Teuchos::rcp_dynamic_cast;
  using Thyra::MultiVectorBase;
  using Thyra::VectorBase;
  using Thyra::multiVectorProductVector;

  // StaggeredFSA ME stores vectors as DMVPV's.  To extract the implicit
  // part of the vector, cast it to DMVPV,  extract the multi-vector,
  // cast it to a product multi-vector, extract the IMEX block, then
  // create a DMVPV from it.

  if(full == Teuchos::null)
    return Teuchos::null;

  if (this->numExplicitOnlyBlocks_==0)
    return full;

  const RCP<const DMVPV> full_dmvpv = rcp_dynamic_cast<const DMVPV>(full,true);
  const RCP<const MultiVectorBase<Scalar> > full_mv =
    full_dmvpv->getMultiVector();
  const RCP<const PMVB> blk_full_mv =
    rcp_dynamic_cast<const PMVB>(full_mv,true);

  // special case where the implicit terms are not blocked
  const int numBlocks = blk_full_mv->productSpace()->numBlocks();
  const int numExplicitBlocks = this->numExplicitOnlyBlocks_;
  if (numBlocks == numExplicitBlocks+1) {
    const RCP<const MultiVectorBase<Scalar> > imex_mv =
      blk_full_mv->getMultiVectorBlock(numExplicitBlocks);
    return multiVectorProductVector(imex_dxdp_prod_space_, imex_mv);
  }

  // Not supposed to get here, apparently
  TEUCHOS_ASSERT(false);
  return Teuchos::null;
}

template <typename Scalar>
Teuchos::RCP<Thyra::VectorBase<Scalar> >
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
getExplicitOnlyVector(
  const Teuchos::RCP<Thyra::VectorBase<Scalar> > & full) const
{
  using Teuchos::RCP;
  using Teuchos::rcp_dynamic_cast;
  using Thyra::MultiVectorBase;
  using Thyra::VectorBase;
  using Thyra::multiVectorProductVectorSpace;
  using Thyra::multiVectorProductVector;

  // StaggeredFSA ME stores vectors as DMVPV's.  To extract the explicit
  // part of the vector, cast it to DMVPV,  extract the multi-vector,
  // cast it to a product multi-vector, extract the explicit block, then
  // create a DMVPV from it.

  if(full == Teuchos::null)
    return Teuchos::null;

  if (this->numExplicitOnlyBlocks_==0)
    return full;

  const RCP<DMVPV> full_dmvpv = rcp_dynamic_cast<DMVPV>(full,true);
  const RCP<MultiVectorBase<Scalar> > full_mv =
    full_dmvpv->getNonconstMultiVector();
  const RCP<PMVB> blk_full_mv = rcp_dynamic_cast<PMVB>(full_mv,true);

  // special case where the explicit terms are not blocked
  const int numExplicitBlocks = this->numExplicitOnlyBlocks_;
  if (numExplicitBlocks == 1) {
    const RCP<MultiVectorBase<Scalar> > explicit_mv =
      blk_full_mv->getNonconstMultiVectorBlock(0);
    return multiVectorProductVector(explicit_dydp_prod_space_, explicit_mv);
  }

  // Not supposed to get here, apparently
  TEUCHOS_ASSERT(false);
  return Teuchos::null;
}

template <typename Scalar>
Teuchos::RCP<const Thyra::VectorBase<Scalar> >
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
getExplicitOnlyVector(
  const Teuchos::RCP<const Thyra::VectorBase<Scalar> > & full) const
{
  using Teuchos::RCP;
  using Teuchos::rcp_dynamic_cast;
  using Thyra::MultiVectorBase;
  using Thyra::VectorBase;
  using Thyra::multiVectorProductVectorSpace;
  using Thyra::multiVectorProductVector;

  // StaggeredFSA ME stores vectors as DMVPV's.  To extract the explicit
  // part of the vector, cast it to DMVPV,  extract the multi-vector,
  // cast it to a product multi-vector, extract the explicit block, then
  // create a DMVPV from it.

  if(full == Teuchos::null)
    return Teuchos::null;

  if (this->numExplicitOnlyBlocks_==0)
    return full;

  const RCP<const DMVPV> full_dmvpv = rcp_dynamic_cast<const DMVPV>(full,true);
  const RCP<const MultiVectorBase<Scalar> > full_mv =
    full_dmvpv->getMultiVector();
  const RCP<const PMVB> blk_full_mv =
    rcp_dynamic_cast<const PMVB>(full_mv,true);

  // special case where the explicit terms are not blocked
  const int numExplicitBlocks = this->numExplicitOnlyBlocks_;
  if (numExplicitBlocks == 1) {
    const RCP<const MultiVectorBase<Scalar> > explicit_mv =
      blk_full_mv->getMultiVectorBlock(0);
    return multiVectorProductVector(explicit_dydp_prod_space_, explicit_mv);
  }

  // Not supposed to get here, apparently
  TEUCHOS_ASSERT(false);
  return Teuchos::null;
}

template <typename Scalar>
Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
getForwardModel() const
{
  return forwardModel_;
}

template <typename Scalar>
void
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
setForwardSolutionHistory(
  const Teuchos::RCP<const Tempus::SolutionHistory<Scalar> >& sh)
{
  sh_ = sh;
  t_interp_ = Teuchos::ScalarTraits<Scalar>::rmax();
  fsaExplicitModel_->setForwardSolutionHistory(sh);
  // We handle interpolation for fsaImplicitModel in evalModelImpl()
}

template <typename Scalar>
void
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
setForwardSolutionState(
  const Teuchos::RCP<const Tempus::SolutionState<Scalar> >& s)
{
  sh_ = Teuchos::null;
  forward_state_ = s;
  buildIMEXStates();
  fsaExplicitModel_->setForwardSolutionState(s);
  fsaImplicitModel_->setForwardSolutionState(implicit_x_state_);
}

template <typename Scalar>
void
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
setSolver(const Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> >& solver,
          const bool force_W_update)
{
  // Make sure we have the useImplicitModel_ flag set since
  // force_W_update = true will force a model evaluation
  bool tf = forwardModel_->getUseImplicitModel();
  Teuchos::RCP<WrapperModelEvaluatorPairPartIMEX_Basic<Scalar> > nc_forwardModel = Teuchos::rcp_const_cast<WrapperModelEvaluatorPairPartIMEX_Basic<Scalar> >(forwardModel_);
  nc_forwardModel->setUseImplicitModel(true);
  fsaImplicitModel_->setSolver(solver, force_W_update);
  nc_forwardModel->setUseImplicitModel(tf);
}

template <typename Scalar>
Thyra::ModelEvaluatorBase::InArgs<Scalar>
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
createInArgs() const
{
  using Teuchos::RCP;
  using Teuchos::rcp_dynamic_cast;
  using Thyra::createMember;

  Thyra::ModelEvaluatorBase::InArgs<Scalar> inArgs = Base::createInArgs();

  // Set p to be the correct product vector form for the explicit only vector y
  if (this->useImplicitModel_ == true) {
    if (inArgs.get_p(this->parameterIndex_)!= Teuchos::null) {
      RCP<DMVPV> dydp =
        rcp_dynamic_cast<DMVPV>(createMember(*explicit_dydp_prod_space_),true);
      Thyra::assign(dydp->getNonconstMultiVector().ptr(), Scalar(0.0));
      inArgs.set_p(this->parameterIndex_, dydp);
    }
  }
  return inArgs;
}

template <typename Scalar>
void
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
evalModelImpl(const Thyra::ModelEvaluatorBase::InArgs<Scalar>  & inArgs,
              const Thyra::ModelEvaluatorBase::OutArgs<Scalar> & outArgs) const
{
  typedef Thyra::ModelEvaluatorBase MEB;
  using Teuchos::RCP;
  using Teuchos::rcp_dynamic_cast;
  using Teuchos::Range1D;

  // Interpolate forward solution at supplied time, reusing previous
  // interpolation if possible
  Scalar forward_t;
  if (sh_ != Teuchos::null) {
    forward_t = inArgs.get_t();
    if (t_interp_ != forward_t) {
      if (nc_forward_state_ == Teuchos::null)
        nc_forward_state_ = sh_->interpolateState(forward_t);
      else
        sh_->interpolateState(forward_t, nc_forward_state_.get());
      forward_state_ = nc_forward_state_;
      t_interp_ = forward_t;
      buildIMEXStates();
      fsaImplicitModel_->setForwardSolutionState(implicit_x_state_);
    }
  }
  else {
    TEUCHOS_ASSERT(forward_state_ != Teuchos::null);
    forward_t = forward_state_->getTime();
  }

  const int p_index = this->parameterIndex_;

  //
  // From Base::evalModelImpl()
  //
  RCP<const Thyra::VectorBase<Scalar> > x = inArgs.get_x();
  RCP<Thyra::VectorBase<Scalar> >   x_dot =
    Thyra::createMember(fsaImplicitModel_->get_x_space());
  this->timeDer_->compute(x, x_dot);

  MEB::InArgs<Scalar>  fsaImplicitInArgs (this->wrapperImplicitInArgs_);
  MEB::OutArgs<Scalar> fsaImplicitOutArgs(this->wrapperImplicitOutArgs_);
  if (fsaImplicitInArgs.supports(MEB::IN_ARG_t))
    fsaImplicitInArgs.set_t(inArgs.get_t());
  fsaImplicitInArgs.set_x(x);
  fsaImplicitInArgs.set_x_dot(x_dot);
  for (int i=0; i<fsaImplicitModel_->Np(); ++i) {
    // Copy over parameters except for the parameter for explicit-only vector!
    if ((inArgs.get_p(i) != Teuchos::null) and (i != p_index))
      fsaImplicitInArgs.set_p(i, inArgs.get_p(i));
  }

  // p-vector for index parameterIndex_ is part of the IMEX solution vector,
  // and therefore is an n column multi-vector where n is the number of
  // sensitivity parameters.  Pull out the sensitivity components before
  // passing along to the ME, then use them for adding in dg/dy*dy/dp term.
  TEUCHOS_ASSERT(explicit_y_state_ != Teuchos::null);
  RCP<const Thyra::VectorBase<Scalar> > y =
    explicit_y_state_->getX();
  RCP<const Thyra::MultiVectorBase<Scalar> > dydp;
  if (fsaImplicitInArgs.get_p(p_index) != Teuchos::null) {
    RCP<const Thyra::VectorBase<Scalar> > p =
      fsaImplicitInArgs.get_p(p_index);
    dydp = rcp_dynamic_cast<const DMVPV>(p,true)->getMultiVector();
    fsaImplicitInArgs.set_p(p_index, y);
  }
  if (use_dfdp_as_tangent_) {
    RCP< const Thyra::VectorBase<Scalar> > dydp_vec =
      Thyra::multiVectorProductVector(explicit_dydp_prod_space_, dydp);
    fsaImplicitInArgs.set_p(y_tangent_index_, dydp_vec);
  }

  fsaImplicitOutArgs.set_f(outArgs.get_f());
  fsaImplicitOutArgs.set_W_op(outArgs.get_W_op());

  fsaImplicitModel_->evalModel(fsaImplicitInArgs,fsaImplicitOutArgs);

  // Compute derivative of implicit residual with respect to explicit only
  // vector y, which is passed as a parameter
  if (!use_dfdp_as_tangent_ && outArgs.get_f() != Teuchos::null) {
    MEB::InArgs<Scalar> appImplicitInArgs =
      appImplicitModel_->getNominalValues();
    TEUCHOS_ASSERT(forward_state_ != Teuchos::null);
    RCP< const Thyra::VectorBase<Scalar> > app_x =
      implicit_x_state_->getX();
    RCP< const Thyra::VectorBase<Scalar> > app_x_dot =
      implicit_x_state_->getXDot();
    appImplicitInArgs.set_x(app_x);
    appImplicitInArgs.set_x_dot(app_x_dot);
    for (int i=0; i<appImplicitModel_->Np(); ++i) {
      if (i != p_index)
        appImplicitInArgs.set_p(i, inArgs.get_p(i));
    }
    appImplicitInArgs.set_p(p_index, y);
    if (appImplicitInArgs.supports(MEB::IN_ARG_t))
      appImplicitInArgs.set_t(forward_t);
    MEB::OutArgs<Scalar> appImplicitOutArgs =
      appImplicitModel_->createOutArgs();
    MEB::DerivativeSupport dfdp_support =
      appImplicitOutArgs.supports(MEB::OUT_ARG_DfDp, p_index);
    Thyra::EOpTransp trans = Thyra::NOTRANS;
    if (dfdp_support.supports(MEB::DERIV_LINEAR_OP)) {
      if (my_dfdp_op_ == Teuchos::null)
        my_dfdp_op_ = appImplicitModel_->create_DfDp_op(p_index);
      appImplicitOutArgs.set_DfDp(p_index,
                                  MEB::Derivative<Scalar>(my_dfdp_op_));
      trans = Thyra::NOTRANS;
    }
    else if (dfdp_support.supports(MEB::DERIV_MV_JACOBIAN_FORM)) {
      if (my_dfdp_mv_ == Teuchos::null)
        my_dfdp_mv_ = Thyra::createMembers(
          appImplicitModel_->get_f_space(),
          appImplicitModel_->get_p_space(p_index)->dim());
      appImplicitOutArgs.set_DfDp(
        p_index, MEB::Derivative<Scalar>(my_dfdp_mv_,
                                         MEB::DERIV_MV_JACOBIAN_FORM));
      my_dfdp_op_ = my_dfdp_mv_;
      trans = Thyra::NOTRANS;
    }
    else if (dfdp_support.supports(MEB::DERIV_MV_GRADIENT_FORM)) {
      if (my_dfdp_mv_ == Teuchos::null)
        my_dfdp_mv_ = Thyra::createMembers(
          appImplicitModel_->get_p_space(p_index),
          appImplicitModel_->get_f_space()->dim());
      appImplicitOutArgs.set_DfDp(
        p_index, MEB::Derivative<Scalar>(my_dfdp_mv_,
                                         MEB::DERIV_MV_GRADIENT_FORM));
      my_dfdp_op_ = my_dfdp_mv_;
      trans = Thyra::TRANS;
    }
    else
      TEUCHOS_TEST_FOR_EXCEPTION(
        true, std::logic_error, "Invalid df/dp support");

    appImplicitModel_->evalModel(appImplicitInArgs, appImplicitOutArgs);

    // Add df/dy*dy/dp term to residual
    RCP<Thyra::MultiVectorBase<Scalar> > dfdp =
      rcp_dynamic_cast<DMVPV>(outArgs.get_f(),true)->getNonconstMultiVector();
    my_dfdp_op_->apply(trans, *dydp, dfdp.ptr(), Scalar(1.0), Scalar(1.0));
  }
}

template <typename Scalar>
Teuchos::RCP<const Teuchos::ParameterList>
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
getValidParameters() const
{
  Teuchos::RCP<const Teuchos::ParameterList> fsa_pl =
    StaggeredForwardSensitivityModelEvaluator<Scalar>::getValidParameters();
  Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList(*fsa_pl);
  pl->set<int>("Sensitivity Y Tangent Index", 3);
  return pl;
}

template <typename Scalar>
void
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
buildIMEXStates() const
{
  explicit_y_state_ =
    Teuchos::rcp(
      new SolutionState<Scalar>(
        forward_state_->getMetaData(),
        forwardModel_->getExplicitOnlyVector(forward_state_->getX()),
        forwardModel_->getExplicitOnlyVector(forward_state_->getXDot()),
        forwardModel_->getExplicitOnlyVector(forward_state_->getXDotDot()),
        forward_state_->getStepperState(),
        Teuchos::null));
  implicit_x_state_ =
    Teuchos::rcp(
      new SolutionState<Scalar>(
        forward_state_->getMetaData(),
        forwardModel_->getIMEXVector(forward_state_->getX()),
        forwardModel_->getIMEXVector(forward_state_->getXDot()),
        forwardModel_->getIMEXVector(forward_state_->getXDotDot()),
        forward_state_->getStepperState(),
        Teuchos::null));
}

} // namespace Tempus

#endif // Tempus_ModelEvaluatorPairPartIMEX_StaggeredFSA_impl_hpp