Thyra  Version of the Day
Thyra_ModelEvaluatorHelpers.hpp
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Thyra: Interfaces and Support for Abstract Numerical Algorithms
5 // Copyright (2004) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Roscoe A. Bartlett (bartlettra@ornl.gov)
38 //
39 // ***********************************************************************
40 // @HEADER
41 
42 #ifndef THYRA_MODEL_EVALUATOR_HELPERS_HPP
43 #define THYRA_MODEL_EVALUATOR_HELPERS_HPP
44 
45 
46 #include "Thyra_ModelEvaluator.hpp"
47 
48 
49 namespace Thyra {
50 
51 
59 template<class Scalar>
60 RCP<ModelEvaluatorBase::InArgs<Scalar> >
61 clone( const ModelEvaluatorBase::InArgs<Scalar> &inArgs );
62 
63 
65 template<class Scalar>
66 ModelEvaluatorBase::Derivative<Scalar>
67 derivativeGradient(
68  const RCP<MultiVectorBase<Scalar> > &grad
69  );
70 
71 
73 template<class Scalar>
74 ModelEvaluatorBase::DerivativeMultiVector<Scalar>
75 create_DfDp_mv(
76  const ModelEvaluator<Scalar>& model,
77  int l,
79  );
80 
81 
83 template<class Scalar>
84 ModelEvaluatorBase::DerivativeMultiVector<Scalar>
85 create_DgDx_dot_mv(
86  const ModelEvaluator<Scalar>& model,
87  int j,
89  );
90 
91 
93 template<class Scalar>
94 ModelEvaluatorBase::DerivativeMultiVector<Scalar>
95 create_DgDx_mv(
96  const ModelEvaluator<Scalar>& model,
97  int j,
99  );
100 
101 
103 template<class Scalar>
104 ModelEvaluatorBase::DerivativeMultiVector<Scalar>
105 create_DgDp_mv(
106  const ModelEvaluator<Scalar>& model,
107  int j,
108  int l,
110  );
111 
112 
114 template<class Scalar>
115 ModelEvaluatorBase::DerivativeMultiVector<Scalar>
116 get_dmv(
117  const ModelEvaluatorBase::Derivative<Scalar> &deriv
118  ,const std::string &derivName
119  );
120 
121 
123 template<class Scalar>
124 RCP<MultiVectorBase<Scalar> >
125 get_mv(
126  const ModelEvaluatorBase::Derivative<Scalar> &deriv
127  ,const std::string &derivName
129  );
130 
131 
137 template<class Scalar>
138 void assertDerivSpaces(
139  const std::string &modelEvalDescription,
140  const ModelEvaluatorBase::Derivative<Scalar> &deriv,
141  const std::string &deriv_name,
142  const VectorSpaceBase<Scalar> &fnc_space,
143  const std::string &fnc_space_name,
144  const VectorSpaceBase<Scalar> &var_space,
145  const std::string &var_space_name
146  );
147 
148 
153 template<class Scalar>
154 void assertInArgsOutArgsSetup(
155  const std::string &modelEvalDescription,
156  const ModelEvaluatorBase::InArgs<Scalar> &inArgs,
157  const ModelEvaluatorBase::OutArgs<Scalar> &outArgs
158  );
159 
160 
165 template<class Scalar>
166 void assertInArgsEvalObjects(
167  const ModelEvaluator<Scalar> &model,
168  const ModelEvaluatorBase::InArgs<Scalar> &inArgs
169  );
170 
171 
176 template<class Scalar>
177 void assertOutArgsEvalObjects(
178  const ModelEvaluator<Scalar> &model,
179  const ModelEvaluatorBase::OutArgs<Scalar> &outArgs,
180  const ModelEvaluatorBase::InArgs<Scalar> *inArgs = 0
181  );
182 
183 
185 template<class Scalar>
186 void eval_f(
187  const ModelEvaluator<Scalar> &model
188  ,const VectorBase<Scalar> &x
189  ,VectorBase<Scalar> *f
190  );
191 
192 
194 template<class Scalar>
195 void eval_f_W(
196  const ModelEvaluator<Scalar> &model
197  ,const VectorBase<Scalar> &x
198  ,VectorBase<Scalar> *f
199  ,LinearOpWithSolveBase<Scalar> *W
200  );
201 
202 
204 template<class Scalar>
205 void eval_f(
206  const ModelEvaluator<Scalar> &model
207  ,const VectorBase<Scalar> &x
208  ,const Scalar &t
209  ,VectorBase<Scalar> *f
210  );
211 
212 
214 template<class Scalar>
215 void eval_g(
216  const ModelEvaluator<Scalar> &model,
217  const int l,
218  const VectorBase<Scalar> &p_l,
219  const int j,
220  const Ptr<VectorBase<Scalar> > &g_j
221  );
222 
223 
225 template<class Scalar>
226 void eval_g(
227  const ModelEvaluator<Scalar> &model,
228  const int l,
229  const VectorBase<Scalar> &p_l,
230  const Scalar &t,
231  const int j,
232  VectorBase<Scalar> *g_j
233  );
234 
235 
237 template<class Scalar>
238 void eval_g_DgDp(
239  const ModelEvaluator<Scalar> &model,
240  const int l,
241  const VectorBase<Scalar> &p_l,
242  const int j,
243  const Ptr<VectorBase<Scalar> > &g_j,
244  const ModelEvaluatorBase::Derivative<Scalar> &DgDp_j_l
245  );
246 
247 
249 template<class Scalar>
250 void eval_f(
251  const ModelEvaluator<Scalar> &model
252  ,const VectorBase<Scalar> &x_dot
253  ,const VectorBase<Scalar> &x
255  ,VectorBase<Scalar> *f
256  );
257 
258 
261 template<class Scalar>
262 void eval_f_W(
263  const ModelEvaluator<Scalar> &model
264  ,const VectorBase<Scalar> &x_dot
265  ,const VectorBase<Scalar> &x
267  ,const Scalar &alpha
268  ,const Scalar &beta
269  ,VectorBase<Scalar> *f
270  ,LinearOpWithSolveBase<Scalar> *W
271  );
272 
273 
274 #ifdef HAVE_THYRA_ME_POLYNOMIAL
275 
276 
278 template<class Scalar>
279 void eval_f_poly(
280  const ModelEvaluator<Scalar> &model
281  ,const Teuchos::Polynomial< VectorBase<Scalar> > &x_poly
283  ,Teuchos::Polynomial< VectorBase<Scalar> > *f_poly
284  );
285 
286 
288 template<class Scalar>
289 void eval_f_poly(
290  const ModelEvaluator<Scalar> &model
291  ,const Teuchos::Polynomial< VectorBase<Scalar> > &x_dot_poly
292  ,const VectorBase<Scalar> &x_poly
294  ,Teuchos::Polynomial< VectorBase<Scalar> > *f_poly
295  );
296 
297 
298 #endif // HAVE_THYRA_ME_POLYNOMIAL
299 
300 
301 } // namespace Thyra
302 
303 
304 //
305 // Implementations
306 //
307 
308 
309 #include "Thyra_AssertOp.hpp"
310 #include "Teuchos_Utils.hpp"
311 
312 
313 template<class Scalar>
314 Teuchos::RCP<Thyra::ModelEvaluatorBase::InArgs<Scalar> >
315 Thyra::clone( const ModelEvaluatorBase::InArgs<Scalar> &inArgs )
316 {
317  RCP<ModelEvaluatorBase::InArgs<Scalar> >
318  newInArgs = Teuchos::rcp(new ModelEvaluatorBase::InArgs<Scalar>);
319  *newInArgs = inArgs;
320  return newInArgs;
321 }
322 
323 
324 template<class Scalar>
326 Thyra::derivativeGradient(
327  const RCP<MultiVectorBase<Scalar> > &grad
328  )
329 {
330  return ModelEvaluatorBase::Derivative<Scalar>(
331  grad,
332  ModelEvaluatorBase::DERIV_MV_GRADIENT_FORM
333  );
334 }
335 
336 
337 template<class Scalar>
339 Thyra::create_DfDp_mv(
340  const ModelEvaluator<Scalar>& model,
341  int l,
342  ModelEvaluatorBase::EDerivativeMultiVectorOrientation orientation
343  )
344 {
345  TEUCHOS_TEST_FOR_EXCEPT(!(orientation==ModelEvaluatorBase::DERIV_MV_BY_COL));
346  return createMembers( model.get_f_space(), model.get_p_space(l)->dim() );
347 }
348 
349 
350 template<class Scalar>
352 Thyra::create_DgDx_dot_mv(
353  const ModelEvaluator<Scalar>& model,
354  int j,
355  ModelEvaluatorBase::EDerivativeMultiVectorOrientation orientation
356  )
357 {
358  typedef ModelEvaluatorBase MEB;
359  switch(orientation) {
360  case MEB::DERIV_MV_BY_COL:
361  return
362  MEB::DerivativeMultiVector<Scalar>(
363  createMembers( model.get_g_space(j), model.get_x_space()->dim() )
364  ,MEB::DERIV_MV_BY_COL
365  );
366  case MEB::DERIV_TRANS_MV_BY_ROW:
367  return
368  MEB::DerivativeMultiVector<Scalar>(
369  createMembers( model.get_x_space(), model.get_g_space(j)->dim() )
370  ,MEB::DERIV_TRANS_MV_BY_ROW
371  );
372  default:
373  TEUCHOS_TEST_FOR_EXCEPT(true);
374  }
375  return MEB::DerivativeMultiVector<Scalar>(); // Never executed!
376 }
377 
378 
379 template<class Scalar>
381 Thyra::create_DgDx_mv(
382  const ModelEvaluator<Scalar>& model,
383  int j,
384  ModelEvaluatorBase::EDerivativeMultiVectorOrientation orientation
385  )
386 {
387  return create_DgDx_dot_mv(model,j,orientation);
388 }
389 
390 
391 template<class Scalar>
393 Thyra::create_DgDp_mv(
394  const ModelEvaluator<Scalar>& model,
395  int j,
396  int l,
397  ModelEvaluatorBase::EDerivativeMultiVectorOrientation orientation
398  )
399 {
400  typedef ModelEvaluatorBase MEB;
401  switch(orientation) {
402  case MEB::DERIV_MV_BY_COL:
403  return
404  MEB::DerivativeMultiVector<Scalar>(
405  createMembers( model.get_g_space(j), model.get_p_space(l)->dim() )
406  ,MEB::DERIV_MV_BY_COL
407  );
408  case MEB::DERIV_TRANS_MV_BY_ROW:
409  return
410  MEB::DerivativeMultiVector<Scalar>(
411  createMembers( model.get_p_space(l), model.get_g_space(j)->dim() )
412  ,MEB::DERIV_TRANS_MV_BY_ROW
413  );
414  default:
415  TEUCHOS_TEST_FOR_EXCEPT(true);
416  }
417  return MEB::DerivativeMultiVector<Scalar>(); // Never executed!
418 }
419 
420 
421 template<class Scalar>
423 Thyra::get_dmv(
424  const ModelEvaluatorBase::Derivative<Scalar> &deriv
425  ,const std::string &derivName
426  )
427 {
428  TEUCHOS_TEST_FOR_EXCEPTION(
429  deriv.getLinearOp().get()!=NULL, std::logic_error
430  ,"Error, LinearOpBase type not expected for " << derivName <<"!"
431  );
432  return deriv.getDerivativeMultiVector();
433 }
434 
435 
436 template<class Scalar>
437 Teuchos::RCP<Thyra::MultiVectorBase<Scalar> >
438 Thyra::get_mv(
439  const ModelEvaluatorBase::Derivative<Scalar> &deriv
440  ,const std::string &derivName
441  ,ModelEvaluatorBase::EDerivativeMultiVectorOrientation orientation
442  )
443 {
444  typedef ModelEvaluatorBase MEB;
445  TEUCHOS_TEST_FOR_EXCEPTION(
446  deriv.getLinearOp().get()!=NULL, std::logic_error
447  ,"Error, LinearOpBase type not expected for " << derivName <<"!"
448  );
449  MEB::DerivativeMultiVector<Scalar>
450  dmv = deriv.getDerivativeMultiVector();
451  RCP<MultiVectorBase<Scalar> >
452  mv = dmv.getMultiVector();
453  if( mv.get() ) {
454  TEUCHOS_TEST_FOR_EXCEPTION(
455  dmv.getOrientation() != orientation, std::logic_error
456  ,"Error, the orientation " << toString(dmv.getOrientation()) << " is not the"
457  " expected orientation of " << toString(orientation)
458  << " for " << derivName << "!"
459  );
460  }
461  return mv;
462 }
463 
464 
465 template<class Scalar>
466 void Thyra::assertDerivSpaces(
467  const std::string &modelEvalDescription,
468  const ModelEvaluatorBase::Derivative<Scalar> &deriv,
469  const std::string &deriv_name,
470  const VectorSpaceBase<Scalar> &fnc_space,
471  const std::string &fnc_space_name,
472  const VectorSpaceBase<Scalar> &var_space,
473  const std::string &var_space_name
474  )
475 {
476  typedef ModelEvaluatorBase MEB;
477  if (!is_null(deriv.getLinearOp())) {
478  const RCP<const LinearOpBase<Scalar> > lo = deriv.getLinearOp();
479  if (!is_null(lo->range())) {
481  modelEvalDescription,
482  *lo->range(), deriv_name + ".range()",
483  fnc_space, fnc_space_name
484  );
486  modelEvalDescription,
487  *lo->domain(), deriv_name + ".domain()",
488  var_space, var_space_name
489  );
490  }
491  }
492  else if(!is_null(deriv.getMultiVector())) {
493  const RCP<const LinearOpBase<Scalar> > mv = deriv.getMultiVector();
494  switch(deriv.getMultiVectorOrientation()) {
495  case MEB::DERIV_MV_BY_COL: {
497  modelEvalDescription,
498  *mv->range(), deriv_name + ".range()",
499  fnc_space, fnc_space_name
500  );
502  modelEvalDescription,
503  *mv->domain(), deriv_name + ".domain()",
504  var_space, var_space_name
505  );
506  break;
507  }
508  case MEB::DERIV_TRANS_MV_BY_ROW: {
510  modelEvalDescription,
511  *mv->range(), deriv_name + "^T.range()",
512  var_space, var_space_name
513  );
515  modelEvalDescription,
516  *mv->domain(), deriv_name + "^T.domain()",
517  fnc_space, fnc_space_name
518  );
519  break;
520  }
521 #ifdef TEUCHOS_DEBUG
522  default:
523  TEUCHOS_TEST_FOR_EXCEPT(true);
524 #endif
525  }
526  }
527 }
528 
529 
530 template<class Scalar>
531 void Thyra::assertInArgsOutArgsSetup(
532  const std::string &modelEvalDescription,
533  const ModelEvaluatorBase::InArgs<Scalar> &inArgs,
534  const ModelEvaluatorBase::OutArgs<Scalar> &outArgs
535  )
536 {
537 
538  typedef ModelEvaluatorBase MEB;
539 
540  const int Ng = outArgs.Ng();
541  const int Np = outArgs.Np();
542 
543  // Description
544  TEUCHOS_ASSERT_EQUALITY(inArgs.modelEvalDescription(), modelEvalDescription);
545  TEUCHOS_ASSERT_EQUALITY(outArgs.modelEvalDescription(), modelEvalDescription);
546 
547  // Np
548  TEUCHOS_TEST_FOR_EXCEPTION(
549  inArgs.Np() != outArgs.Np(), std::logic_error,
550  "Error: The underlying model " << modelEvalDescription << " incorrectly\n"
551  "set inArgs.Np() = "<<inArgs.Np()<<" != outArgs.Np() = "
552  <<outArgs.Np()<<"!"
553  );
554 
555  // x_dot
556  TEUCHOS_TEST_FOR_EXCEPTION(
557  inArgs.supports(MEB::IN_ARG_x_dot) && !inArgs.supports(MEB::IN_ARG_x),
558  std::logic_error,
559  "Error: The underlying model " << modelEvalDescription << " supports\n"
560  "x_dot but does not support x!"
561  );
562 
563  // t
564  TEUCHOS_TEST_FOR_EXCEPTION(
565  inArgs.supports(MEB::IN_ARG_x_dot) && !inArgs.supports(MEB::IN_ARG_t),
566  std::logic_error,
567  "Error: The underlying model " << modelEvalDescription << " supports\n"
568  "x_dot but does not support t!"
569  );
570 
571  // W and W_op
572  TEUCHOS_TEST_FOR_EXCEPTION(
573  (
574  ( outArgs.supports(MEB::OUT_ARG_W) || outArgs.supports(MEB::OUT_ARG_W_op) )
575  &&
576  !inArgs.supports(MEB::IN_ARG_x)
577  ),
578  std::logic_error,
579  "Error: The underlying model " << modelEvalDescription << " says that\n"
580  "it supports W and/or W_op but it does not support x!"
581  );
582  TEUCHOS_TEST_FOR_EXCEPTION(
583  (
584  ( outArgs.supports(MEB::OUT_ARG_W) || outArgs.supports(MEB::OUT_ARG_W_op) )
585  &&
586  inArgs.supports(MEB::IN_ARG_x_dot)
587  &&
588  !( inArgs.supports(MEB::IN_ARG_alpha) && inArgs.supports(MEB::IN_ARG_beta) )
589  ),
590  std::logic_error,
591  "Error: The underlying model " << modelEvalDescription << " supports W and/or W_op\n"
592  "and x_dot but it does not support alpha and beta as InArgs!"
593  );
594 
595  for ( int l = 0; l < Np; ++l ) {
596 
597  // DfDp(l): OutArgs checks this automatically!
598 
599  for ( int j = 0; j < Ng; ++j ) {
600 
601  // DgDx_dot(j)
602  TEUCHOS_TEST_FOR_EXCEPTION(
603  ( !outArgs.supports(MEB::OUT_ARG_DgDx_dot,j).none()
604  && !inArgs.supports(MEB::IN_ARG_x_dot) ),
605  std::logic_error,
606  "Error: The underlying model " << modelEvalDescription << " says that\n"
607  "it supports DgDx_dot("<<j<<") but it does not support x_dot!"
608  );
609 
610  // DgDx(j)
611  TEUCHOS_TEST_FOR_EXCEPTION(
612  ( !outArgs.supports(MEB::OUT_ARG_DgDx,j).none()
613  && !inArgs.supports(MEB::IN_ARG_x) ),
614  std::logic_error,
615  "Error: The underlying model " << modelEvalDescription << " says that\n"
616  "it supports DgDx("<<j<<") but it does not support x!"
617  );
618 
619  // DgDp(j,l): OutArgs checks this automatically!
620 
621  }
622 
623  }
624 
625 }
626 
627 
628 template<class Scalar>
629 void Thyra::assertInArgsEvalObjects(
630  const ModelEvaluator<Scalar> &model,
631  const ModelEvaluatorBase::InArgs<Scalar> &inArgs
632  )
633 {
634 
635  typedef ModelEvaluatorBase MEB;
636 
637  const std::string description = model.description();
638  const int Np = inArgs.Np();
639 
640  model.createInArgs().assertSameSupport(inArgs);
641 
642  // x_dot
643  if ( inArgs.supports(MEB::IN_ARG_x_dot) && !is_null(inArgs.get_x_dot()) ) {
645  description, *inArgs.get_x_dot()->space(), *model.get_x_space() );
646  }
647 
648  // x
649  if ( inArgs.supports(MEB::IN_ARG_x) && !is_null(inArgs.get_x()) ) {
651  description, *inArgs.get_x()->space(), *model.get_x_space() );
652  }
653 
654  // p(l)
655  for ( int l = 0; l < Np; ++l ) {
656  if (!is_null(inArgs.get_p(l))) {
658  description, *inArgs.get_p(l)->space(), *model.get_p_space(l) );
659  }
660  }
661 
662 }
663 
664 
665 template<class Scalar>
666 void Thyra::assertOutArgsEvalObjects(
667  const ModelEvaluator<Scalar> &model,
668  const ModelEvaluatorBase::OutArgs<Scalar> &outArgs,
669  const ModelEvaluatorBase::InArgs<Scalar> *inArgs
670  )
671 {
672 
673  typedef ScalarTraits<Scalar> ST;
674  typedef Teuchos::Utils TU;
675  typedef ModelEvaluatorBase MEB;
676 
677  const std::string description = model.description();
678  const int Ng = outArgs.Ng();
679  const int Np = outArgs.Np();
680 
681  if (inArgs) {
682  TEUCHOS_ASSERT_EQUALITY(outArgs.Np(), inArgs->Np());
683  }
684 
685  model.createOutArgs().assertSameSupport(outArgs);
686 
687  // f
688  if ( outArgs.supports(MEB::OUT_ARG_f) && !is_null(outArgs.get_f()) ) {
690  description, *outArgs.get_f()->space(), *model.get_f_space() );
691  }
692 
693  // W
694  if ( outArgs.supports(MEB::OUT_ARG_W) && !is_null(outArgs.get_W()) ) {
695  if (!is_null(outArgs.get_W()->range())) {
697  description, *outArgs.get_W()->range(), *model.get_f_space() );
699  description, *outArgs.get_W()->domain(), *model.get_x_space() );
700  }
701  }
702 
703  // W_op
704  if ( outArgs.supports(MEB::OUT_ARG_W_op) && !is_null(outArgs.get_W_op()) ) {
705  if (!is_null(outArgs.get_W_op()->range())) {
707  description, *outArgs.get_W_op()->range(), *model.get_f_space() );
709  description, *outArgs.get_W_op()->domain(), *model.get_x_space() );
710  }
711  }
712 
713  // alpha and beta (not really in outArgs but can only be validated if W or
714  // W_op is set)
715  if (
716  inArgs
717  &&
718  (
719  ( outArgs.supports(MEB::OUT_ARG_W) && !is_null(outArgs.get_W()) )
720  ||
721  ( outArgs.supports(MEB::OUT_ARG_W_op) && !is_null(outArgs.get_W_op()) )
722  )
723  )
724  {
725  if ( inArgs->supports(MEB::IN_ARG_alpha) && inArgs->supports(MEB::IN_ARG_beta) ) {
726  // 08/25/08 tscoffe: In the block-composed linear operator case for
727  // Rythmos::ImplicitRKModelEvaluator, I need to specify that a given
728  // block is all zeros and I'm depending on the underlying model to
729  // intelligently fill the block with zeros if both alpha and beta are
730  // zero.
731  //TEUCHOS_TEST_FOR_EXCEPT( inArgs->get_alpha() == ST::zero() && inArgs->get_beta() == ST::zero() );
732  }
733  else if ( inArgs->supports(MEB::IN_ARG_beta) ) {
734  TEUCHOS_TEST_FOR_EXCEPT( inArgs->get_beta() == ST::zero() );
735  }
736  }
737 
738  // DfDp(l)
739  if (outArgs.supports(MEB::OUT_ARG_f)) {
740  for ( int l = 0; l < Np; ++l ) {
741  if (!outArgs.supports(MEB::OUT_ARG_DfDp,l).none()) {
743  description,
744  outArgs.get_DfDp(l), "DfDp("+TU::toString(l)+")",
745  *model.get_f_space(), "f_space",
746  *model.get_p_space(l), "p_space("+TU::toString(l)+")"
747  );
748  }
749  }
750  }
751 
752  // g(l)
753  for ( int j = 0; j < Ng; ++j ) {
754  if (!is_null(outArgs.get_g(j))) {
756  description, *outArgs.get_g(j)->space(), *model.get_g_space(j) );
757  }
758  }
759 
760  // DgDx_dot(j)
761  for ( int j = 0; j < Ng; ++j ) {
762  if (!outArgs.supports(MEB::OUT_ARG_DgDx_dot,j).none()) {
764  description,
765  outArgs.get_DgDx_dot(j), "DgDx_dot("+TU::toString(j)+")",
766  *model.get_g_space(j), "g_space("+TU::toString(j)+")",
767  *model.get_x_space(), "x_space"
768  );
769  }
770  }
771 
772  // DgDx(j)
773  for ( int j = 0; j < Ng; ++j ) {
774  if (!outArgs.supports(MEB::OUT_ARG_DgDx,j).none()) {
776  description,
777  outArgs.get_DgDx(j), "DgDx("+TU::toString(j)+")",
778  *model.get_g_space(j), "g_space("+TU::toString(j)+")",
779  *model.get_x_space(), "x_space"
780  );
781  }
782  }
783 
784  // Assert DgDp(j,l)
785  for ( int j = 0; j < Ng; ++j ) {
786  for ( int l = 0; l < Np; ++l ) {
787  if (!outArgs.supports(MEB::OUT_ARG_DgDp,j,l).none()) {
788  const std::string j_str = TU::toString(j);
789  const std::string l_str = TU::toString(l);
791  description,
792  outArgs.get_DgDp(j,l), "DgDp("+j_str+","+l_str+")",
793  *model.get_g_space(j), "g_space("+j_str+")",
794  *model.get_p_space(l), "p_space("+l_str+")"
795  );
796  }
797  }
798  }
799 
800 }
801 
802 
803 template<class Scalar>
804 void Thyra::eval_f(
805  const ModelEvaluator<Scalar> &model
806  ,const VectorBase<Scalar> &x
807  ,VectorBase<Scalar> *f
808  )
809 {
810  typedef ModelEvaluatorBase MEB;
811  MEB::InArgs<Scalar> inArgs = model.createInArgs();
812  MEB::OutArgs<Scalar> outArgs = model.createOutArgs();
813  inArgs.set_x(Teuchos::rcp(&x,false));
814  outArgs.set_f(Teuchos::rcp(f,false));
815  model.evalModel(inArgs,outArgs);
816 }
817 
818 
819 template<class Scalar>
820 void Thyra::eval_f_W(
821  const ModelEvaluator<Scalar> &model
822  ,const VectorBase<Scalar> &x
823  ,VectorBase<Scalar> *f
824  ,LinearOpWithSolveBase<Scalar> *W
825  )
826 {
827 
828  typedef ModelEvaluatorBase MEB;
829 
830  MEB::InArgs<Scalar> inArgs = model.createInArgs();
831  MEB::OutArgs<Scalar> outArgs = model.createOutArgs();
832 
833  inArgs.set_x(Teuchos::rcp(&x,false));
834 
835  if (f) outArgs.set_f(Teuchos::rcp(f,false));
836  if (W) outArgs.set_W(Teuchos::rcp(W,false));
837 
838  model.evalModel(inArgs,outArgs);
839 
840 }
841 
842 
843 template<class Scalar>
844 void Thyra::eval_f(
845  const ModelEvaluator<Scalar> &model
846  ,const VectorBase<Scalar> &x
847  ,const Scalar &t
848  ,VectorBase<Scalar> *f
849  )
850 {
851  typedef ModelEvaluatorBase MEB;
852  MEB::InArgs<Scalar> inArgs = model.createInArgs();
853  MEB::OutArgs<Scalar> outArgs = model.createOutArgs();
854  inArgs.set_x(Teuchos::rcp(&x,false));
855  if(inArgs.supports(MEB::IN_ARG_t)) inArgs.set_t(t);
856  outArgs.set_f(Teuchos::rcp(f,false));
857  model.evalModel(inArgs,outArgs);
858 }
859 
860 
861 template<class Scalar>
862 void Thyra::eval_g(
863  const ModelEvaluator<Scalar> &model,
864  const int l,
865  const VectorBase<Scalar> &p_l,
866  const int j,
867  const Ptr<VectorBase<Scalar> > &g_j
868  )
869 {
870  typedef ModelEvaluatorBase MEB;
871  MEB::InArgs<Scalar> inArgs = model.createInArgs();
872  MEB::OutArgs<Scalar> outArgs= model.createOutArgs();
873  inArgs.set_p(l, Teuchos::rcpFromRef(p_l));
874  outArgs.set_g(j, Teuchos::rcpFromRef(*g_j));
875  model.evalModel(inArgs,outArgs);
876 }
877 
878 
879 template<class Scalar>
880 void Thyra::eval_g(
881  const ModelEvaluator<Scalar> &model,
882  const int l,
883  const VectorBase<Scalar> &p_l,
884  const Scalar &t,
885  const int j,
886  VectorBase<Scalar> *g_j
887  )
888 {
889  typedef ModelEvaluatorBase MEB;
890  MEB::InArgs<Scalar> inArgs = model.createInArgs();
891  MEB::OutArgs<Scalar> outArgs= model.createOutArgs();
892  inArgs.set_p(l,Teuchos::rcp(&p_l,false));
893  inArgs.set_t(t);
894  outArgs.set_g(j,Teuchos::rcp(g_j,false));
895  model.evalModel(inArgs,outArgs);
896 }
897 
898 
899 template<class Scalar>
900 void Thyra::eval_g_DgDp(
901  const ModelEvaluator<Scalar> &model,
902  const int l,
903  const VectorBase<Scalar> &p_l,
904  const int j,
905  const Ptr<VectorBase<Scalar> > &g_j,
906  const ModelEvaluatorBase::Derivative<Scalar> &DgDp_j_l
907  )
908 {
909  typedef ModelEvaluatorBase MEB;
910  MEB::InArgs<Scalar> inArgs = model.createInArgs();
911  MEB::OutArgs<Scalar> outArgs= model.createOutArgs();
912  inArgs.set_p(l, Teuchos::rcpFromRef(p_l));
913  if (!is_null(g_j)) {
914  outArgs.set_g(j, Teuchos::rcpFromPtr(g_j));
915  }
916  if (!DgDp_j_l.isEmpty()) {
917  outArgs.set_DgDp(j, l, DgDp_j_l);
918  }
919  model.evalModel(inArgs,outArgs);
920 }
921 
922 
923 template<class Scalar>
924 void Thyra::eval_f(
925  const ModelEvaluator<Scalar> &model
926  ,const VectorBase<Scalar> &x_dot
927  ,const VectorBase<Scalar> &x
928  ,const typename ModelEvaluatorBase::InArgs<Scalar>::ScalarMag &t
929  ,VectorBase<Scalar> *f
930  )
931 {
932 
933  typedef ModelEvaluatorBase MEB;
934 
935  MEB::InArgs<Scalar> inArgs = model.createInArgs();
936  MEB::OutArgs<Scalar> outArgs = model.createOutArgs();
937 
938  inArgs.set_x_dot(Teuchos::rcp(&x_dot,false));
939  inArgs.set_x(Teuchos::rcp(&x,false));
940  if(inArgs.supports(MEB::IN_ARG_t))
941  inArgs.set_t(t);
942 
943  outArgs.set_f(Teuchos::rcp(f,false));
944 
945  model.evalModel(inArgs,outArgs);
946 
947 }
948 
949 
950 template<class Scalar>
951 void Thyra::eval_f_W(
952  const ModelEvaluator<Scalar> &model
953  ,const VectorBase<Scalar> &x_dot
954  ,const VectorBase<Scalar> &x
955  ,const typename ModelEvaluatorBase::InArgs<Scalar>::ScalarMag &t
956  ,const Scalar &alpha
957  ,const Scalar &beta
958  ,VectorBase<Scalar> *f
959  ,LinearOpWithSolveBase<Scalar> *W
960  )
961 {
962 
963  typedef ModelEvaluatorBase MEB;
964 
965  MEB::InArgs<Scalar> inArgs = model.createInArgs();
966  MEB::OutArgs<Scalar> outArgs = model.createOutArgs();
967 
968  inArgs.set_x_dot(Teuchos::rcp(&x_dot,false));
969  inArgs.set_x(Teuchos::rcp(&x,false));
970  if(inArgs.supports(MEB::IN_ARG_t))
971  inArgs.set_t(t);
972  inArgs.set_alpha(alpha);
973  inArgs.set_beta(beta);
974 
975  if(f) outArgs.set_f(Teuchos::rcp(f,false));
976  if(W) outArgs.set_W(Teuchos::rcp(W,false));
977 
978  model.evalModel(inArgs,outArgs);
979 
980 }
981 
982 
983 #ifdef HAVE_THYRA_ME_POLYNOMIAL
984 
985 
986 template<class Scalar>
987 void Thyra::eval_f_poly(
988  const ModelEvaluator<Scalar> &model
989  ,const Teuchos::Polynomial< VectorBase<Scalar> > &x_poly
990  ,const typename ModelEvaluatorBase::InArgs<Scalar>::ScalarMag &t
991  ,Teuchos::Polynomial< VectorBase<Scalar> > *f_poly
992  )
993 {
994 
995  typedef ModelEvaluatorBase MEB;
996 
997  MEB::InArgs<Scalar> inArgs = model.createInArgs();
998  MEB::OutArgs<Scalar> outArgs = model.createOutArgs();
999 
1000  inArgs.set_x_poly(Teuchos::rcp(&x_poly,false));
1001  if(inArgs.supports(MEB::IN_ARG_t))
1002  inArgs.set_t(t);
1003 
1004  outArgs.set_f_poly(Teuchos::rcp(f_poly,false));
1005 
1006  model.evalModel(inArgs,outArgs);
1007 
1008 }
1009 
1010 
1011 template<class Scalar>
1012 void Thyra::eval_f_poly(
1013  const ModelEvaluator<Scalar> &model
1014  ,const Teuchos::Polynomial< VectorBase<Scalar> > &x_dot_poly
1015  ,const VectorBase<Scalar> &x_poly
1016  ,const typename ModelEvaluatorBase::InArgs<Scalar>::ScalarMag &t
1017  ,Teuchos::Polynomial< VectorBase<Scalar> > *f_poly
1018  )
1019 {
1020 
1021  typedef ModelEvaluatorBase MEB;
1022 
1023  MEB::InArgs<Scalar> inArgs = model.createInArgs();
1024  MEB::OutArgs<Scalar> outArgs = model.createOutArgs();
1025 
1026  inArgs.set_x_dot_poly(Teuchos::rcp(&x_dot_poly,false));
1027  inArgs.set_x_poly(Teuchos::rcp(&x_poly,false));
1028  if(inArgs.supports(MEB::IN_ARG_t))
1029  inArgs.set_t(t);
1030 
1031  outArgs.set_f_poly(Teuchos::rcp(f_poly,false));
1032 
1033  model.evalModel(inArgs,outArgs);
1034 
1035 }
1036 
1037 
1038 #endif // HAVE_THYRA_ME_POLYNOMIAL
1039 
1040 
1041 #endif // THYRA_MODEL_EVALUATOR_HELPERS_HPP
#define THYRA_ASSERT_VEC_SPACES(FUNC_NAME, VS1, VS2)
This is a very useful macro that should be used to validate that two vector spaces are compatible...
std::string toString(ModelEvaluatorBase::EInArgsMembers)
Simple aggregate class that stores a derivative object as a general linear operator or as a multi-vec...
Simple aggregate class for a derivative object represented as a column-wise multi-vector or its trans...
Teuchos::ScalarTraits< Scalar >::magnitudeType ScalarMag
ModelEvaluatorBase::DerivativeMultiVector< Scalar > create_DgDx_dot_mv(const ModelEvaluator< Scalar > &model, int j, ModelEvaluatorBase::EDerivativeMultiVectorOrientation orientation)
void assertDerivSpaces(const std::string &modelEvalDescription, const ModelEvaluatorBase::Derivative< Scalar > &deriv, const std::string &deriv_name, const VectorSpaceBase< Scalar > &fnc_space, const std::string &fnc_space_name, const VectorSpaceBase< Scalar > &var_space, const std::string &var_space_name)
Assert that that Thyra objects imbedded in a Derivative object matches its function and variable spac...
#define THYRA_ASSERT_VEC_SPACES_NAMES(FUNC_NAME, VS1, VS1_NAME, VS2, VS2_NAME)
Helper assertion macro.
const char * toString(EConj conj)
Return a string name for a EOpTransp value. `*.
RCP< MultiVectorBase< Scalar > > createMembers(const RCP< const VectorSpaceBase< Scalar > > &vs, int numMembers, const std::string &label="")
Create a set of vector members (a MultiVectorBase) from the vector space.