Tempus  Version of the Day
Time Integration
Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp
Go to the documentation of this file.
1 // @HEADER
2 // ****************************************************************************
3 // Tempus: Copyright (2017) Sandia Corporation
4 //
5 // Distributed under BSD 3-clause license (See accompanying file Copyright.txt)
6 // ****************************************************************************
7 // @HEADER
8 
9 #ifndef Tempus_ModelEvaluatorPairPartIMEX_StaggeredFSA_impl_hpp
10 #define Tempus_ModelEvaluatorPairPartIMEX_StaggeredFSA_impl_hpp
11 
12 #include "Thyra_VectorStdOps.hpp"
13 #include "Thyra_MultiVectorStdOps.hpp"
14 
15 namespace Tempus {
16 
17 template <typename Scalar>
18 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
19 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA(
20  const Teuchos::RCP<const WrapperModelEvaluatorPairPartIMEX_Basic<Scalar> >& forwardModel,
21  const Teuchos::RCP<const Teuchos::ParameterList>& pList) :
22  forwardModel_(forwardModel),
23  use_dfdp_as_tangent_(false),
24  y_tangent_index_(3)
25 {
26  using Teuchos::RCP;
27  using Teuchos::rcp;
28  using Thyra::multiVectorProductVectorSpace;
29 
30  RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
31  if (pList != Teuchos::null)
32  *pl = *pList;
33  pl->validateParametersAndSetDefaults(*this->getValidParameters());
34  use_dfdp_as_tangent_ = pl->get<bool>("Use DfDp as Tangent");
35  y_tangent_index_ = pl->get<int>("Sensitivity Y Tangent Index");
36  pl->remove("Sensitivity Y Tangent Index");
37 
38  appExplicitModel_ = forwardModel_->getExplicitModel();
39  appImplicitModel_ = forwardModel_->getImplicitModel();
40  fsaExplicitModel_ = rcp(new FSAME(appExplicitModel_, pl));
41  fsaImplicitModel_ = rcp(new FSAME(appImplicitModel_, pl));
42 
43  const int y_param_index = forwardModel_->getParameterIndex();
44  const int sens_param_index = pl->get<int>("Sensitivity Parameter Index");
45  const int num_sens_param =
46  appImplicitModel_->get_p_space(sens_param_index)->dim();
47  RCP<const Thyra::VectorSpaceBase<Scalar> > explicit_y_space =
48  appImplicitModel_->get_p_space(y_param_index);
49  RCP<const Thyra::VectorSpaceBase<Scalar> > implicit_x_space =
50  appImplicitModel_->get_x_space();
51  explicit_dydp_prod_space_ =
52  multiVectorProductVectorSpace(explicit_y_space, num_sens_param);
53  imex_dxdp_prod_space_ =
54  multiVectorProductVectorSpace(implicit_x_space, num_sens_param);
55 
56  Base::setup(fsaExplicitModel_, fsaImplicitModel_,
57  forwardModel_->getNumExplicitOnlyBlocks(),
58  y_param_index);
59 }
60 
61 template <typename Scalar>
62 void
63 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
64 initialize()
65 {
66  using Teuchos::RCP;
67  using Teuchos::rcp_dynamic_cast;
68 
69  this->useImplicitModel_ = true;
70  this->wrapperImplicitInArgs_ = this->createInArgs();
71  this->wrapperImplicitOutArgs_ = this->createOutArgs();
72  this->useImplicitModel_ = false;
73 
74  RCP<const Thyra::VectorBase<Scalar> > z =
75  this->explicitModel_->getNominalValues().get_x();
76 
77  // A Thyra::VectorSpace requirement
78  TEUCHOS_TEST_FOR_EXCEPTION( !(getIMEXVector(z)->space()->isCompatible(
79  *(this->implicitModel_->get_x_space()))),
80  std::logic_error,
81  "Error - WrapperModelEvaluatorPairIMEX_StaggeredFSA::initialize()\n"
82  " Explicit and Implicit vector x spaces are incompatible!\n"
83  " Explicit vector x space = " << *(getIMEXVector(z)->space()) << "\n"
84  " Implicit vector x space = " << *(this->implicitModel_->get_x_space()) <<
85  "\n");
86 
87  // Valid number of blocks?
88  const RCP<const DMVPV> z_dmvpv = rcp_dynamic_cast<const DMVPV>(z,true);
89  const RCP<const Thyra::MultiVectorBase<Scalar> > z_mv =
90  z_dmvpv->getMultiVector();
91  RCP<const PMVB> zPVector = rcp_dynamic_cast<const PMVB>(z_mv);
92  TEUCHOS_TEST_FOR_EXCEPTION( zPVector == Teuchos::null, std::logic_error,
93  "Error - WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::initialize()\n"
94  " was given a VectorBase that could not be cast to a\n"
95  " ProductVectorBase!\n");
96 
97  int numBlocks = zPVector->productSpace()->numBlocks();
98 
99  TEUCHOS_TEST_FOR_EXCEPTION( !(0 <= this->numExplicitOnlyBlocks_ and
100  this->numExplicitOnlyBlocks_ < numBlocks),
101  std::logic_error,
102  "Error - WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::initialize()\n"
103  "Invalid number of explicit-only blocks = " <<
104  this->numExplicitOnlyBlocks_ << "\n"
105  "Should be in the interval [0, numBlocks) = [0, " << numBlocks << ")\n");
106 }
107 
108 template <typename Scalar>
109 Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> >
110 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
111 get_p_space(int i) const
112 {
113  if (this->useImplicitModel_) {
114  if (i == this->parameterIndex_)
115  return explicit_dydp_prod_space_;
116  else
117  return appImplicitModel_->get_p_space(i);
118  }
119 
120  return appExplicitModel_->get_p_space(i);
121 }
122 
123 template <typename Scalar>
124 Teuchos::RCP<Thyra::VectorBase<Scalar> >
125 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
126 getIMEXVector(const Teuchos::RCP<Thyra::VectorBase<Scalar> > & full) const
127 {
128  using Teuchos::RCP;
129  using Teuchos::rcp_dynamic_cast;
130  using Thyra::MultiVectorBase;
131  using Thyra::VectorBase;
132  using Thyra::multiVectorProductVector;
133 
134  // StaggeredFSA ME stores vectors as DMVPV's. To extract the implicit
135  // part of the vector, cast it to DMVPV, extract the multi-vector,
136  // cast it to a product multi-vector, extract the IMEX block, then
137  // create a DMVPV from it.
138 
139  if(full == Teuchos::null)
140  return Teuchos::null;
141 
142  if (this->numExplicitOnlyBlocks_==0)
143  return full;
144 
145  const RCP<DMVPV> full_dmvpv = rcp_dynamic_cast<DMVPV>(full,true);
146  const RCP<MultiVectorBase<Scalar> > full_mv =
147  full_dmvpv->getNonconstMultiVector();
148  const RCP<PMVB> blk_full_mv = rcp_dynamic_cast<PMVB>(full_mv,true);
149 
150  // special case where the implicit terms are not blocked
151  const int numBlocks = blk_full_mv->productSpace()->numBlocks();
152  const int numExplicitBlocks = this->numExplicitOnlyBlocks_;
153  if (numBlocks == numExplicitBlocks+1) {
154  const RCP<MultiVectorBase<Scalar> > imex_mv =
155  blk_full_mv->getNonconstMultiVectorBlock(numExplicitBlocks);
156  return multiVectorProductVector(imex_dxdp_prod_space_, imex_mv);
157  }
158 
159  // Not supposed to get here, apparently
160  TEUCHOS_ASSERT(false);
161  return Teuchos::null;
162 }
163 
164 template <typename Scalar>
165 Teuchos::RCP<const Thyra::VectorBase<Scalar> >
166 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
167 getIMEXVector(const Teuchos::RCP<const Thyra::VectorBase<Scalar> > & full) const
168 {
169  using Teuchos::RCP;
170  using Teuchos::rcp_dynamic_cast;
171  using Thyra::MultiVectorBase;
172  using Thyra::VectorBase;
173  using Thyra::multiVectorProductVector;
174 
175  // StaggeredFSA ME stores vectors as DMVPV's. To extract the implicit
176  // part of the vector, cast it to DMVPV, extract the multi-vector,
177  // cast it to a product multi-vector, extract the IMEX block, then
178  // create a DMVPV from it.
179 
180  if(full == Teuchos::null)
181  return Teuchos::null;
182 
183  if (this->numExplicitOnlyBlocks_==0)
184  return full;
185 
186  const RCP<const DMVPV> full_dmvpv = rcp_dynamic_cast<const DMVPV>(full,true);
187  const RCP<const MultiVectorBase<Scalar> > full_mv =
188  full_dmvpv->getMultiVector();
189  const RCP<const PMVB> blk_full_mv =
190  rcp_dynamic_cast<const PMVB>(full_mv,true);
191 
192  // special case where the implicit terms are not blocked
193  const int numBlocks = blk_full_mv->productSpace()->numBlocks();
194  const int numExplicitBlocks = this->numExplicitOnlyBlocks_;
195  if (numBlocks == numExplicitBlocks+1) {
196  const RCP<const MultiVectorBase<Scalar> > imex_mv =
197  blk_full_mv->getMultiVectorBlock(numExplicitBlocks);
198  return multiVectorProductVector(imex_dxdp_prod_space_, imex_mv);
199  }
200 
201  // Not supposed to get here, apparently
202  TEUCHOS_ASSERT(false);
203  return Teuchos::null;
204 }
205 
206 template <typename Scalar>
207 Teuchos::RCP<Thyra::VectorBase<Scalar> >
208 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
209 getExplicitOnlyVector(
210  const Teuchos::RCP<Thyra::VectorBase<Scalar> > & full) const
211 {
212  using Teuchos::RCP;
213  using Teuchos::rcp_dynamic_cast;
214  using Thyra::MultiVectorBase;
215  using Thyra::VectorBase;
216  using Thyra::multiVectorProductVectorSpace;
217  using Thyra::multiVectorProductVector;
218 
219  // StaggeredFSA ME stores vectors as DMVPV's. To extract the explicit
220  // part of the vector, cast it to DMVPV, extract the multi-vector,
221  // cast it to a product multi-vector, extract the explicit block, then
222  // create a DMVPV from it.
223 
224  if(full == Teuchos::null)
225  return Teuchos::null;
226 
227  if (this->numExplicitOnlyBlocks_==0)
228  return full;
229 
230  const RCP<DMVPV> full_dmvpv = rcp_dynamic_cast<DMVPV>(full,true);
231  const RCP<MultiVectorBase<Scalar> > full_mv =
232  full_dmvpv->getNonconstMultiVector();
233  const RCP<PMVB> blk_full_mv = rcp_dynamic_cast<PMVB>(full_mv,true);
234 
235  // special case where the explicit terms are not blocked
236  const int numExplicitBlocks = this->numExplicitOnlyBlocks_;
237  if (numExplicitBlocks == 1) {
238  const RCP<MultiVectorBase<Scalar> > explicit_mv =
239  blk_full_mv->getNonconstMultiVectorBlock(0);
240  return multiVectorProductVector(explicit_dydp_prod_space_, explicit_mv);
241  }
242 
243  // Not supposed to get here, apparently
244  TEUCHOS_ASSERT(false);
245  return Teuchos::null;
246 }
247 
248 template <typename Scalar>
249 Teuchos::RCP<const Thyra::VectorBase<Scalar> >
250 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
251 getExplicitOnlyVector(
252  const Teuchos::RCP<const Thyra::VectorBase<Scalar> > & full) const
253 {
254  using Teuchos::RCP;
255  using Teuchos::rcp_dynamic_cast;
256  using Thyra::MultiVectorBase;
257  using Thyra::VectorBase;
258  using Thyra::multiVectorProductVectorSpace;
259  using Thyra::multiVectorProductVector;
260 
261  // StaggeredFSA ME stores vectors as DMVPV's. To extract the explicit
262  // part of the vector, cast it to DMVPV, extract the multi-vector,
263  // cast it to a product multi-vector, extract the explicit block, then
264  // create a DMVPV from it.
265 
266  if(full == Teuchos::null)
267  return Teuchos::null;
268 
269  if (this->numExplicitOnlyBlocks_==0)
270  return full;
271 
272  const RCP<const DMVPV> full_dmvpv = rcp_dynamic_cast<const DMVPV>(full,true);
273  const RCP<const MultiVectorBase<Scalar> > full_mv =
274  full_dmvpv->getMultiVector();
275  const RCP<const PMVB> blk_full_mv =
276  rcp_dynamic_cast<const PMVB>(full_mv,true);
277 
278  // special case where the explicit terms are not blocked
279  const int numExplicitBlocks = this->numExplicitOnlyBlocks_;
280  if (numExplicitBlocks == 1) {
281  const RCP<const MultiVectorBase<Scalar> > explicit_mv =
282  blk_full_mv->getMultiVectorBlock(0);
283  return multiVectorProductVector(explicit_dydp_prod_space_, explicit_mv);
284  }
285 
286  // Not supposed to get here, apparently
287  TEUCHOS_ASSERT(false);
288  return Teuchos::null;
289 }
290 
291 template <typename Scalar>
292 Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >
293 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
294 getForwardModel() const
295 {
296  return forwardModel_;
297 }
298 
299 template <typename Scalar>
300 void
301 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
302 setForwardSolutionHistory(
303  const Teuchos::RCP<const Tempus::SolutionHistory<Scalar> >& sh)
304 {
305  sh_ = sh;
306  t_interp_ = Teuchos::ScalarTraits<Scalar>::rmax();
307  fsaExplicitModel_->setForwardSolutionHistory(sh);
308  // We handle interpolation for fsaImplicitModel in evalModelImpl()
309 }
310 
311 template <typename Scalar>
312 void
313 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
314 setForwardSolutionState(
315  const Teuchos::RCP<const Tempus::SolutionState<Scalar> >& s)
316 {
317  sh_ = Teuchos::null;
318  forward_state_ = s;
319  buildIMEXStates();
320  fsaExplicitModel_->setForwardSolutionState(s);
321  fsaImplicitModel_->setForwardSolutionState(implicit_x_state_);
322 }
323 
324 template <typename Scalar>
325 void
326 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
327 setSolver(const Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> >& solver,
328  const bool force_W_update)
329 {
330  // Make sure we have the useImplicitModel_ flag set since
331  // force_W_update = true will force a model evaluation
332  bool tf = forwardModel_->getUseImplicitModel();
333  Teuchos::RCP<WrapperModelEvaluatorPairPartIMEX_Basic<Scalar> > nc_forwardModel = Teuchos::rcp_const_cast<WrapperModelEvaluatorPairPartIMEX_Basic<Scalar> >(forwardModel_);
334  nc_forwardModel->setUseImplicitModel(true);
335  fsaImplicitModel_->setSolver(solver, force_W_update);
336  nc_forwardModel->setUseImplicitModel(tf);
337 }
338 
339 template <typename Scalar>
340 Thyra::ModelEvaluatorBase::InArgs<Scalar>
341 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
342 createInArgs() const
343 {
344  using Teuchos::RCP;
345  using Teuchos::rcp_dynamic_cast;
346  using Thyra::createMember;
347 
348  Thyra::ModelEvaluatorBase::InArgs<Scalar> inArgs = Base::createInArgs();
349 
350  // Set p to be the correct product vector form for the explicit only vector y
351  if (this->useImplicitModel_ == true) {
352  if (inArgs.get_p(this->parameterIndex_)!= Teuchos::null) {
353  RCP<DMVPV> dydp =
354  rcp_dynamic_cast<DMVPV>(createMember(*explicit_dydp_prod_space_),true);
355  Thyra::assign(dydp->getNonconstMultiVector().ptr(), Scalar(0.0));
356  inArgs.set_p(this->parameterIndex_, dydp);
357  }
358  }
359  return inArgs;
360 }
361 
362 template <typename Scalar>
363 void
364 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
365 evalModelImpl(const Thyra::ModelEvaluatorBase::InArgs<Scalar> & inArgs,
366  const Thyra::ModelEvaluatorBase::OutArgs<Scalar> & outArgs) const
367 {
368  typedef Thyra::ModelEvaluatorBase MEB;
369  using Teuchos::RCP;
370  using Teuchos::rcp_dynamic_cast;
371  using Teuchos::Range1D;
372 
373  // Interpolate forward solution at supplied time, reusing previous
374  // interpolation if possible
375  Scalar forward_t;
376  if (sh_ != Teuchos::null) {
377  forward_t = inArgs.get_t();
378  if (t_interp_ != forward_t) {
379  if (nc_forward_state_ == Teuchos::null)
380  nc_forward_state_ = sh_->interpolateState(forward_t);
381  else
382  sh_->interpolateState(forward_t, nc_forward_state_.get());
383  forward_state_ = nc_forward_state_;
384  t_interp_ = forward_t;
385  buildIMEXStates();
386  fsaImplicitModel_->setForwardSolutionState(implicit_x_state_);
387  }
388  }
389  else {
390  TEUCHOS_ASSERT(forward_state_ != Teuchos::null);
391  forward_t = forward_state_->getTime();
392  }
393 
394  const int p_index = this->parameterIndex_;
395 
396  //
397  // From Base::evalModelImpl()
398  //
399  RCP<const Thyra::VectorBase<Scalar> > x = inArgs.get_x();
400  RCP<Thyra::VectorBase<Scalar> > x_dot =
401  Thyra::createMember(fsaImplicitModel_->get_x_space());
402  this->timeDer_->compute(x, x_dot);
403 
404  MEB::InArgs<Scalar> fsaImplicitInArgs (this->wrapperImplicitInArgs_);
405  MEB::OutArgs<Scalar> fsaImplicitOutArgs(this->wrapperImplicitOutArgs_);
406  if (fsaImplicitInArgs.supports(MEB::IN_ARG_t))
407  fsaImplicitInArgs.set_t(inArgs.get_t());
408  fsaImplicitInArgs.set_x(x);
409  fsaImplicitInArgs.set_x_dot(x_dot);
410  for (int i=0; i<fsaImplicitModel_->Np(); ++i) {
411  // Copy over parameters except for the parameter for explicit-only vector!
412  if ((inArgs.get_p(i) != Teuchos::null) and (i != p_index))
413  fsaImplicitInArgs.set_p(i, inArgs.get_p(i));
414  }
415 
416  // p-vector for index parameterIndex_ is part of the IMEX solution vector,
417  // and therefore is an n column multi-vector where n is the number of
418  // sensitivity parameters. Pull out the sensitivity components before
419  // passing along to the ME, then use them for adding in dg/dy*dy/dp term.
420  TEUCHOS_ASSERT(explicit_y_state_ != Teuchos::null);
421  RCP<const Thyra::VectorBase<Scalar> > y =
422  explicit_y_state_->getX();
423  RCP<const Thyra::MultiVectorBase<Scalar> > dydp;
424  if (fsaImplicitInArgs.get_p(p_index) != Teuchos::null) {
425  RCP<const Thyra::VectorBase<Scalar> > p =
426  fsaImplicitInArgs.get_p(p_index);
427  dydp = rcp_dynamic_cast<const DMVPV>(p,true)->getMultiVector();
428  fsaImplicitInArgs.set_p(p_index, y);
429  }
430  if (use_dfdp_as_tangent_) {
431  RCP< const Thyra::VectorBase<Scalar> > dydp_vec =
432  Thyra::multiVectorProductVector(explicit_dydp_prod_space_, dydp);
433  fsaImplicitInArgs.set_p(y_tangent_index_, dydp_vec);
434  }
435 
436  fsaImplicitOutArgs.set_f(outArgs.get_f());
437  fsaImplicitOutArgs.set_W_op(outArgs.get_W_op());
438 
439  fsaImplicitModel_->evalModel(fsaImplicitInArgs,fsaImplicitOutArgs);
440 
441  // Compute derivative of implicit residual with respect to explicit only
442  // vector y, which is passed as a parameter
443  if (!use_dfdp_as_tangent_ && outArgs.get_f() != Teuchos::null) {
444  MEB::InArgs<Scalar> appImplicitInArgs =
445  appImplicitModel_->getNominalValues();
446  TEUCHOS_ASSERT(forward_state_ != Teuchos::null);
447  RCP< const Thyra::VectorBase<Scalar> > app_x =
448  implicit_x_state_->getX();
449  RCP< const Thyra::VectorBase<Scalar> > app_x_dot =
450  implicit_x_state_->getXDot();
451  appImplicitInArgs.set_x(app_x);
452  appImplicitInArgs.set_x_dot(app_x_dot);
453  for (int i=0; i<appImplicitModel_->Np(); ++i) {
454  if (i != p_index)
455  appImplicitInArgs.set_p(i, inArgs.get_p(i));
456  }
457  appImplicitInArgs.set_p(p_index, y);
458  if (appImplicitInArgs.supports(MEB::IN_ARG_t))
459  appImplicitInArgs.set_t(forward_t);
460  MEB::OutArgs<Scalar> appImplicitOutArgs =
461  appImplicitModel_->createOutArgs();
462  MEB::DerivativeSupport dfdp_support =
463  appImplicitOutArgs.supports(MEB::OUT_ARG_DfDp, p_index);
464  Thyra::EOpTransp trans = Thyra::NOTRANS;
465  if (dfdp_support.supports(MEB::DERIV_LINEAR_OP)) {
466  if (my_dfdp_op_ == Teuchos::null)
467  my_dfdp_op_ = appImplicitModel_->create_DfDp_op(p_index);
468  appImplicitOutArgs.set_DfDp(p_index,
469  MEB::Derivative<Scalar>(my_dfdp_op_));
470  trans = Thyra::NOTRANS;
471  }
472  else if (dfdp_support.supports(MEB::DERIV_MV_JACOBIAN_FORM)) {
473  if (my_dfdp_mv_ == Teuchos::null)
474  my_dfdp_mv_ = Thyra::createMembers(
475  appImplicitModel_->get_f_space(),
476  appImplicitModel_->get_p_space(p_index)->dim());
477  appImplicitOutArgs.set_DfDp(
478  p_index, MEB::Derivative<Scalar>(my_dfdp_mv_,
479  MEB::DERIV_MV_JACOBIAN_FORM));
480  my_dfdp_op_ = my_dfdp_mv_;
481  trans = Thyra::NOTRANS;
482  }
483  else if (dfdp_support.supports(MEB::DERIV_MV_GRADIENT_FORM)) {
484  if (my_dfdp_mv_ == Teuchos::null)
485  my_dfdp_mv_ = Thyra::createMembers(
486  appImplicitModel_->get_p_space(p_index),
487  appImplicitModel_->get_f_space()->dim());
488  appImplicitOutArgs.set_DfDp(
489  p_index, MEB::Derivative<Scalar>(my_dfdp_mv_,
490  MEB::DERIV_MV_GRADIENT_FORM));
491  my_dfdp_op_ = my_dfdp_mv_;
492  trans = Thyra::TRANS;
493  }
494  else
495  TEUCHOS_TEST_FOR_EXCEPTION(
496  true, std::logic_error, "Invalid df/dp support");
497 
498  appImplicitModel_->evalModel(appImplicitInArgs, appImplicitOutArgs);
499 
500  // Add df/dy*dy/dp term to residual
501  RCP<Thyra::MultiVectorBase<Scalar> > dfdp =
502  rcp_dynamic_cast<DMVPV>(outArgs.get_f(),true)->getNonconstMultiVector();
503  my_dfdp_op_->apply(trans, *dydp, dfdp.ptr(), Scalar(1.0), Scalar(1.0));
504  }
505 }
506 
507 template <typename Scalar>
508 Teuchos::RCP<const Teuchos::ParameterList>
509 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
510 getValidParameters() const
511 {
512  Teuchos::RCP<const Teuchos::ParameterList> fsa_pl =
513  StaggeredForwardSensitivityModelEvaluator<Scalar>::getValidParameters();
514  Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList(*fsa_pl);
515  pl->set<int>("Sensitivity Y Tangent Index", 3);
516  return pl;
517 }
518 
519 template <typename Scalar>
520 void
521 WrapperModelEvaluatorPairPartIMEX_StaggeredFSA<Scalar>::
522 buildIMEXStates() const
523 {
524  explicit_y_state_ =
525  Teuchos::rcp(
526  new SolutionState<Scalar>(
527  forward_state_->getMetaData(),
528  forwardModel_->getExplicitOnlyVector(forward_state_->getX()),
529  forwardModel_->getExplicitOnlyVector(forward_state_->getXDot()),
530  forwardModel_->getExplicitOnlyVector(forward_state_->getXDotDot()),
531  forward_state_->getStepperState()));
532  implicit_x_state_ =
533  Teuchos::rcp(
534  new SolutionState<Scalar>(
535  forward_state_->getMetaData(),
536  forwardModel_->getIMEXVector(forward_state_->getX()),
537  forwardModel_->getIMEXVector(forward_state_->getXDot()),
538  forwardModel_->getIMEXVector(forward_state_->getXDotDot()),
539  forward_state_->getStepperState()));
540 }
541 
542 } // namespace Tempus
543 
544 #endif // Tempus_ModelEvaluatorPairPartIMEX_StaggeredFSA_impl_hpp
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::fsaExplicitModel_
Teuchos::RCP< FSAME > fsaExplicitModel_
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_decl.hpp:131
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::getIMEXVector
virtual Teuchos::RCP< Thyra::VectorBase< Scalar > > getIMEXVector(const Teuchos::RCP< Thyra::VectorBase< Scalar > > &full) const
Extract IMEX vector from a full solution vector.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:126
Tempus::WrapperModelEvaluatorPairPartIMEX_Basic::setup
void setup(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &explicitModel, const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &implicitModel, int numExplicitOnlyBlocks=0, int parameterIndex=-1)
Setup ME when using default constructor – for derived classes.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_Basic_impl.hpp:43
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA
WrapperModelEvaluatorPairPartIMEX_StaggeredFSA(const Teuchos::RCP< const WrapperModelEvaluatorPairPartIMEX_Basic< Scalar > > &forwardModel, const Teuchos::RCP< const Teuchos::ParameterList > &pList=Teuchos::null)
Constructor.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:19
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::y_tangent_index_
int y_tangent_index_
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_decl.hpp:135
Tempus::WrapperModelEvaluatorPairPartIMEX_Basic
ModelEvaluator pair for implicit and explicit (IMEX) evaulations.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_Basic_decl.hpp:37
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::get_p_space
virtual Teuchos::RCP< const Thyra::VectorSpaceBase< Scalar > > get_p_space(int i) const
Get the p space.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:111
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::appImplicitModel_
Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > appImplicitModel_
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_decl.hpp:130
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::evalModelImpl
virtual void evalModelImpl(const Thyra::ModelEvaluatorBase::InArgs< Scalar > &inArgs, const Thyra::ModelEvaluatorBase::OutArgs< Scalar > &outArgs) const
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:365
Tempus
Definition: Tempus_AdjointAuxSensitivityModelEvaluator_decl.hpp:20
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::getExplicitOnlyVector
virtual Teuchos::RCP< Thyra::VectorBase< Scalar > > getExplicitOnlyVector(const Teuchos::RCP< Thyra::VectorBase< Scalar > > &full) const
Extract explicit-only vector from a full solution vector.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:209
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::buildIMEXStates
void buildIMEXStates() const
Build implicit x and end explicit y states from forward_state_.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:522
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::getForwardModel
virtual Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > getForwardModel() const
Get the underlying forward model.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:294
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::explicit_dydp_prod_space_
Teuchos::RCP< const DMVPVS > explicit_dydp_prod_space_
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_decl.hpp:137
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::setForwardSolutionHistory
virtual void setForwardSolutionHistory(const Teuchos::RCP< const Tempus::SolutionHistory< Scalar > > &sh)
Set solution history from forward state evaluation (for interpolation)
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:302
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::forwardModel_
Teuchos::RCP< const WrapperModelEvaluatorPairPartIMEX_Basic< Scalar > > forwardModel_
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_decl.hpp:128
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::getValidParameters
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:510
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::appExplicitModel_
Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > appExplicitModel_
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_decl.hpp:129
Tempus::SolutionState
Solution state for integrators and steppers. SolutionState contains the metadata for solutions and th...
Definition: Tempus_SolutionState_decl.hpp:56
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::FSAME
StaggeredForwardSensitivityModelEvaluator< Scalar > FSAME
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_decl.hpp:126
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::setSolver
virtual void setSolver(const Teuchos::RCP< Thyra::NonlinearSolverBase< Scalar > > &solver, const bool force_W_update)
Set the solver of the underlying model if you want to reuse it.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:327
Tempus::SolutionHistory
SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of...
Definition: Tempus_Integrator.hpp:25
Tempus::WrapperModelEvaluatorPairPartIMEX_Basic::setUseImplicitModel
virtual void setUseImplicitModel(bool tf)
Set parameter to switch wrapperME base functions between explicit and implicit functions.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_Basic_decl.hpp:145
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::imex_dxdp_prod_space_
Teuchos::RCP< const DMVPVS > imex_dxdp_prod_space_
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_decl.hpp:138
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::initialize
virtual void initialize()
Initialize after setting member data.
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:64
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::setForwardSolutionState
virtual void setForwardSolutionState(const Teuchos::RCP< const Tempus::SolutionState< Scalar > > &s)
Set solution state from forward state evaluation (for frozen state)
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:314
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::fsaImplicitModel_
Teuchos::RCP< FSAME > fsaImplicitModel_
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_decl.hpp:132
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::createInArgs
virtual Thyra::ModelEvaluatorBase::InArgs< Scalar > createInArgs() const
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_impl.hpp:342
Tempus::StaggeredForwardSensitivityModelEvaluator::getValidParameters
static Teuchos::RCP< const Teuchos::ParameterList > getValidParameters()
Definition: Tempus_StaggeredForwardSensitivityModelEvaluator_impl.hpp:467
Tempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA::use_dfdp_as_tangent_
bool use_dfdp_as_tangent_
Definition: Tempus_WrapperModelEvaluatorPairPartIMEX_StaggeredFSA_decl.hpp:134