EpetraExt Package Browser (Single Doxygen Collection) Development
Loading...
Searching...
No Matches
EpetraExt_ModelEvaluator.cpp
Go to the documentation of this file.
1//@HEADER
2// ***********************************************************************
3//
4// EpetraExt: Epetra Extended - Linear Algebra Services Package
5// Copyright (2011) Sandia Corporation
6//
7// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
8// the U.S. Government retains certain rights in this software.
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 Michael A. Heroux (maherou@sandia.gov)
38//
39// ***********************************************************************
40//@HEADER
41
43#include "Teuchos_implicit_cast.hpp"
44
45
46namespace EpetraExt {
47
48
49//
50// ModelEvaluator::InArgs
51//
52
53
55 :modelEvalDescription_("WARNING! THIS INARGS OBJECT IS UNINITALIZED!")
56{
57 std::fill_n(&supports_[0],NUM_E_IN_ARGS_MEMBERS,false);
58 t_ = 0.0;
59 alpha_ = 0.0;
60 omega_ = 0.0;
61 beta_ = 0.0;
62}
63
64
66{
67 TEUCHOS_TEST_FOR_EXCEPTION(
68 int(arg)>=NUM_E_IN_ARGS_MEMBERS || int(arg) < 0,std::logic_error
69 ,"model = \'"<<modelEvalDescription_<<"\': Error, arg="<<toString(arg)<<" is invalid!"
70 );
71 return supports_[arg];
72}
73
75{
76 assert_l(l);
77 return supports_p_sg_[l];
78}
79
81{
82 assert_l(l);
83 return supports_p_mp_[l];
84}
85
87{
88 TEUCHOS_TEST_FOR_EXCEPTION(
89 int(arg)>=NUM_E_IN_ARGS_MEMBERS || int(arg) < 0,std::logic_error
90 ,"model = \'"<<modelEvalDescription_<<"\':Error, arg="<<toString(arg)<<" is invalid!"
91 );
92 supports_[arg] = supportsIt;
93}
94
95void ModelEvaluator::InArgs::_setSupports(EInArgs_p_sg /* arg */, int l, bool supportsIt)
96{
97 assert_l(l);
98 supports_p_sg_[l] = supportsIt;
99}
100
101void ModelEvaluator::InArgs::_setSupports(EInArgs_p_mp /* arg */, int l, bool supportsIt)
102{
103 assert_l(l);
104 supports_p_mp_[l] = supportsIt;
105}
106
107
109{
110 TEUCHOS_TEST_FOR_EXCEPTION(
111 !supports_[arg], std::logic_error
112 ,"EpetraExt::ModelEvaluator::InArgs::assert_supports(arg): model = \'"<<modelEvalDescription_<<"\': Error, "
113 "The argument arg = " << toString(arg) << " is not supported!"
114 );
115}
116
118{
119 assert_l(l);
120 TEUCHOS_TEST_FOR_EXCEPTION(
121 !supports_p_sg_[l], std::logic_error
122 ,"EpetraExt::ModelEvaluator::InArgs::assert_supports(IN_ARG_p_sg,l): "
123 "model = \'"<<modelEvalDescription_<<"\': Error,"
124 "The argument p_sg(l) with index l = " << l << " is not supported!"
125 );
126}
127
129{
130 assert_l(l);
131 TEUCHOS_TEST_FOR_EXCEPTION(
132 !supports_p_mp_[l], std::logic_error
133 ,"EpetraExt::ModelEvaluator::InArgs::assert_supports(IN_ARG_p_mp,l): "
134 "model = \'"<<modelEvalDescription_<<"\': Error,"
135 "The argument p_mp(l) with index l = " << l << " is not supported!"
136 );
137}
138
139
141{
142 TEUCHOS_TEST_FOR_EXCEPTION(
143 !( 0 <= l && l < Np() ), std::logic_error
144 ,"EpetraExt::ModelEvaluator::InArgs::assert_l(l): model = \'"<<modelEvalDescription_<<"\': Error, "
145 "The parameter l = " << l << " is not in the range [0,"<<Np()-1<<"]!"
146 );
147}
148
149
150//
151// ModelEvaluator::OutArgs
152//
153
154
156 :modelEvalDescription_("WARNING! THIS OUTARGS OBJECT IS UNINITALIZED!"),
157 isFailed_( false )
158{
159 std::fill_n(&supports_[0],NUM_E_OUT_ARGS_MEMBERS,false);
160}
161
162
164{
165 TEUCHOS_TEST_FOR_EXCEPTION(
166 int(arg)>=NUM_E_OUT_ARGS_MEMBERS || int(arg) < 0,std::logic_error
167 ,"model = \'"<<modelEvalDescription_<<"\': Error, arg="<<toString(arg)<<" is invalid!"
168 );
169 return supports_[arg];
170}
171
172
175{
176 assert_l(l);
177 return supports_DfDp_[l];
178}
179
180
183{
184 assert_j(j);
185 return supports_DgDx_dot_[j];
186}
187
188
191{
192 assert_j(j);
193 return supports_DgDx_dotdot_[j];
194}
195
196
199{
200 assert_j(j);
201 return supports_DgDx_[j];
202}
203
204
207{
208 assert_j(j);
209 assert_l(l);
210 return supports_DgDp_[ j*Np() + l ];
211}
212
214{
215 assert_j(j);
216 return supports_g_sg_[j];
217}
218
221{
222 assert_l(l);
223 return supports_DfDp_sg_[l];
224}
225
226
229{
230 assert_j(j);
231 return supports_DgDx_dot_sg_[j];
232}
233
234
237{
238 assert_j(j);
239 return supports_DgDx_dotdot_sg_[j];
240}
241
242
245{
246 assert_j(j);
247 return supports_DgDx_sg_[j];
248}
249
252{
253 assert_j(j);
254 assert_l(l);
255 return supports_DgDp_sg_[ j*Np() + l ];
256}
257
259{
260 assert_j(j);
261 return supports_g_mp_[j];
262}
263
266{
267 assert_l(l);
268 return supports_DfDp_mp_[l];
269}
270
271
274{
275 assert_j(j);
276 return supports_DgDx_dot_mp_[j];
277}
278
279
282{
283 assert_j(j);
284 return supports_DgDx_dotdot_mp_[j];
285}
286
287
290{
291 assert_j(j);
292 return supports_DgDx_mp_[j];
293}
294
297{
298 assert_j(j);
299 assert_l(l);
300 return supports_DgDp_mp_[ j*Np() + l ];
301}
302
303
305{
306 using Teuchos::implicit_cast;
307 bool areSet = false;
308 switch(arg) {
309 case OUT_ARG_f: {
310 if (!is_null(f_)) areSet = true;
311 if (!is_null(W_)) areSet = true;
312 for ( int l = 0; l < implicit_cast<int>(DfDp_.size()); ++l )
313 if(!DfDp_[l].isEmpty()) areSet = true;
314 break;
315 }
316 default:
317 TEUCHOS_TEST_FOR_EXCEPTION(true,std::logic_error,
318 "ModelEvaluator::OutArgs::funcOrDerivesAreSet(arg): Error, we can not handle"
319 " the argument " << toString(arg) << "yet!");
320 }
321 return areSet;
322}
323
325{
326 isFailed_ = true;
327 // TODO: Set objects to NaN?
328}
329
331{
332 return isFailed_;
333}
334
335
336void ModelEvaluator::OutArgs::_setModelEvalDescription( const std::string &theModelEvalDescription )
337{
338 modelEvalDescription_ = theModelEvalDescription;
339}
340
341
342void ModelEvaluator::OutArgs::_set_Np_Ng(int Np_in, int Ng_in)
343{
344 if(Np_in) {
345 supports_DfDp_.resize(Np_in);
346 DfDp_.resize(Np_in);
347 std::fill_n(DfDp_.begin(),Np_in,Derivative());
348 DfDp_properties_.resize(Np_in);
349 std::fill_n(DfDp_properties_.begin(),Np_in,DerivativeProperties());
350
351 supports_DfDp_sg_.resize(Np_in);
352 DfDp_sg_.resize(Np_in);
353 std::fill_n(DfDp_sg_.begin(),Np_in,SGDerivative());
354 DfDp_sg_properties_.resize(Np_in);
355 std::fill_n(DfDp_sg_properties_.begin(),Np_in,DerivativeProperties());
356
357 supports_DfDp_mp_.resize(Np_in);
358 DfDp_mp_.resize(Np_in);
359 std::fill_n(DfDp_mp_.begin(),Np_in,MPDerivative());
360 DfDp_mp_properties_.resize(Np_in);
361 std::fill_n(DfDp_mp_properties_.begin(),Np_in,DerivativeProperties());
362 }
363 if(Ng_in) {
364 g_.resize(Ng_in);
365 supports_DgDx_dot_.resize(Ng_in);
366 DgDx_dot_.resize(Ng_in);
367 std::fill_n(DgDx_dot_.begin(),Ng_in,Derivative());
368 DgDx_dot_properties_.resize(Ng_in);
369 std::fill_n(DgDx_dot_properties_.begin(),Ng_in,DerivativeProperties());
370 supports_DgDx_dotdot_.resize(Ng_in);
371 DgDx_dotdot_.resize(Ng_in);
372 std::fill_n(DgDx_dotdot_.begin(),Ng_in,Derivative());
373 DgDx_dotdot_properties_.resize(Ng_in);
374 std::fill_n(DgDx_dotdot_properties_.begin(),Ng_in,DerivativeProperties());
375 supports_DgDx_.resize(Ng_in);
376 DgDx_.resize(Ng_in);
377 std::fill_n(DgDx_.begin(),Ng_in,Derivative());
378 DgDx_properties_.resize(Ng_in);
379 std::fill_n(DgDx_properties_.begin(),Ng_in,DerivativeProperties());
380
381 g_sg_.resize(Ng_in);
382 supports_g_sg_.resize(Ng_in);
383 supports_DgDx_dot_sg_.resize(Ng_in);
384 DgDx_dot_sg_.resize(Ng_in);
385 std::fill_n(DgDx_dot_sg_.begin(),Ng_in,SGDerivative());
386 DgDx_dot_sg_properties_.resize(Ng_in);
387 std::fill_n(DgDx_dot_sg_properties_.begin(),Ng_in,DerivativeProperties());
388 supports_DgDx_dotdot_sg_.resize(Ng_in);
389 DgDx_dotdot_sg_.resize(Ng_in);
390 std::fill_n(DgDx_dotdot_sg_.begin(),Ng_in,SGDerivative());
391 DgDx_dotdot_sg_properties_.resize(Ng_in);
392 std::fill_n(DgDx_dotdot_sg_properties_.begin(),Ng_in,DerivativeProperties());
393 supports_DgDx_sg_.resize(Ng_in);
394 DgDx_sg_.resize(Ng_in);
395 std::fill_n(DgDx_sg_.begin(),Ng_in,SGDerivative());
396 DgDx_sg_properties_.resize(Ng_in);
397 std::fill_n(DgDx_sg_properties_.begin(),Ng_in,DerivativeProperties());
398
399 g_mp_.resize(Ng_in);
400 supports_g_mp_.resize(Ng_in);
401 supports_DgDx_dot_mp_.resize(Ng_in);
402 DgDx_dot_mp_.resize(Ng_in);
403 std::fill_n(DgDx_dot_mp_.begin(),Ng_in,MPDerivative());
404 DgDx_dot_mp_properties_.resize(Ng_in);
405 std::fill_n(DgDx_dot_mp_properties_.begin(),Ng_in,DerivativeProperties());
406 supports_DgDx_dotdot_mp_.resize(Ng_in);
407 DgDx_dotdot_mp_.resize(Ng_in);
408 std::fill_n(DgDx_dotdot_mp_.begin(),Ng_in,MPDerivative());
409 DgDx_dotdot_mp_properties_.resize(Ng_in);
410 std::fill_n(DgDx_dotdot_mp_properties_.begin(),Ng_in,DerivativeProperties());
411 supports_DgDx_mp_.resize(Ng_in);
412 DgDx_mp_.resize(Ng_in);
413 std::fill_n(DgDx_mp_.begin(),Ng_in,MPDerivative());
414 DgDx_mp_properties_.resize(Ng_in);
415 std::fill_n(DgDx_mp_properties_.begin(),Ng_in,DerivativeProperties());
416 }
417 if(Np_in && Ng_in) {
418 const int NpNg = Np_in*Ng_in;
419 supports_DgDp_.resize(NpNg);
420 DgDp_.resize(NpNg);
421 std::fill_n(DgDp_.begin(),NpNg,Derivative());
422 DgDp_properties_.resize(NpNg);
423 std::fill_n(DgDp_properties_.begin(),NpNg,DerivativeProperties());
424
425 supports_DgDp_sg_.resize(NpNg);
426 DgDp_sg_.resize(NpNg);
427 std::fill_n(DgDp_sg_.begin(),NpNg,SGDerivative());
428 DgDp_sg_properties_.resize(NpNg);
429 std::fill_n(DgDp_sg_properties_.begin(),NpNg,DerivativeProperties());
430
431 supports_DgDp_mp_.resize(NpNg);
432 DgDp_mp_.resize(NpNg);
433 std::fill_n(DgDp_mp_.begin(),NpNg,MPDerivative());
434 DgDp_mp_properties_.resize(NpNg);
435 std::fill_n(DgDp_mp_properties_.begin(),NpNg,DerivativeProperties());
436 }
437}
438
440{
441 TEUCHOS_TEST_FOR_EXCEPTION(
442 int(arg)>=NUM_E_OUT_ARGS_MEMBERS || int(arg) < 0,std::logic_error
443 ,"model = \'"<<modelEvalDescription_<<"\': Error, arg="<<toString(arg)<<" is invalid!"
444 );
445 supports_[arg] = supportsIt;
446}
447
448
449void ModelEvaluator::OutArgs::_setSupports( EOutArgsDfDp /* arg */, int l, const DerivativeSupport& theSupports )
450{
451 assert_l(l);
452 supports_DfDp_[l] = theSupports;
453}
454
455
457{
458 assert_j(j);
459 supports_DgDx_dot_[j] = theSupports;
460}
461
462
464{
465 assert_j(j);
466 supports_DgDx_dotdot_[j] = theSupports;
467}
468
469
470void ModelEvaluator::OutArgs::_setSupports( EOutArgsDgDx /* arg */, int j, const DerivativeSupport& theSupports )
471{
472 assert_j(j);
473 supports_DgDx_[j] = theSupports;
474}
475
476
477void ModelEvaluator::OutArgs::_setSupports( EOutArgsDgDp /* arg */, int j, int l, const DerivativeSupport& theSupports )
478{
479 assert_j(j);
480 assert_l(l);
481 supports_DgDp_[ j*Np() + l ] = theSupports;
482}
483
484void ModelEvaluator::OutArgs::_setSupports( EOutArgs_g_sg /* arg */, int j, bool supportsIt )
485{
486 assert_j(j);
487 supports_g_sg_[j] = supportsIt;
488}
489
491{
492 assert_l(l);
493 supports_DfDp_sg_[l] = theSupports;
494}
495
496
498{
499 assert_j(j);
500 supports_DgDx_dot_sg_[j] = theSupports;
501}
502
504{
505 assert_j(j);
506 supports_DgDx_dotdot_sg_[j] = theSupports;
507}
508
509
511{
512 assert_j(j);
513 supports_DgDx_sg_[j] = theSupports;
514}
515
516void ModelEvaluator::OutArgs::_setSupports( EOutArgsDgDp_sg /* arg */, int j, int l, const DerivativeSupport& theSupports )
517{
518 assert_j(j);
519 assert_l(l);
520 supports_DgDp_sg_[ j*Np() + l ] = theSupports;
521}
522
523void ModelEvaluator::OutArgs::_setSupports( EOutArgs_g_mp /* arg */, int j, bool supportsIt )
524{
525 assert_j(j);
526 supports_g_mp_[j] = supportsIt;
527}
528
530{
531 assert_l(l);
532 supports_DfDp_mp_[l] = theSupports;
533}
534
535
537{
538 assert_j(j);
539 supports_DgDx_dot_mp_[j] = theSupports;
540}
541
543{
544 assert_j(j);
545 supports_DgDx_dotdot_mp_[j] = theSupports;
546}
547
548
550{
551 assert_j(j);
552 supports_DgDx_mp_[j] = theSupports;
553}
554
555void ModelEvaluator::OutArgs::_setSupports( EOutArgsDgDp_mp /* arg */, int j, int l, const DerivativeSupport& theSupports )
556{
557 assert_j(j);
558 assert_l(l);
559 supports_DgDp_mp_[ j*Np() + l ] = theSupports;
560}
561
562
564{
565 W_properties_ = W_properties;
566}
567
569{
570 WPrec_properties_ = WPrec_properties;
571}
572
574{
575 assert_supports(OUT_ARG_DfDp,l);
576 DfDp_properties_[l] = properties;
577}
578
579
581{
582 assert_supports(OUT_ARG_DgDx_dot,j);
583 DgDx_dot_properties_[j] = properties;
584}
585
587{
588 assert_supports(OUT_ARG_DgDx_dotdot,j);
589 DgDx_dotdot_properties_[j] = properties;
590}
591
592
594{
595 assert_supports(OUT_ARG_DgDx,j);
596 DgDx_properties_[j] = properties;
597}
598
599
601{
602 assert_supports(OUT_ARG_DgDp,j,l);
603 DgDp_properties_[ j*Np() + l ] = properties;
604}
605
607{
608 assert_supports(OUT_ARG_DfDp_sg,l);
609 DfDp_sg_properties_[l] = properties;
610}
611
612
614{
615 assert_supports(OUT_ARG_DgDx_dot_sg,j);
616 DgDx_dot_sg_properties_[j] = properties;
617}
618
620{
621 assert_supports(OUT_ARG_DgDx_dotdot_sg,j);
622 DgDx_dotdot_sg_properties_[j] = properties;
623}
624
625
627{
628 assert_supports(OUT_ARG_DgDx_sg,j);
629 DgDx_sg_properties_[j] = properties;
630}
631
633{
634 assert_supports(OUT_ARG_DgDp_sg,j,l);
635 DgDp_sg_properties_[ j*Np() + l ] = properties;
636}
637
638
640{
641 assert_supports(OUT_ARG_DfDp_mp,l);
642 DfDp_mp_properties_[l] = properties;
643}
644
645
647{
648 assert_supports(OUT_ARG_DgDx_dot_mp,j);
649 DgDx_dot_mp_properties_[j] = properties;
650}
651
653{
654 assert_supports(OUT_ARG_DgDx_dotdot_mp,j);
655 DgDx_dotdot_mp_properties_[j] = properties;
656}
657
658
660{
661 assert_supports(OUT_ARG_DgDx_mp,j);
662 DgDx_mp_properties_[j] = properties;
663}
664
666{
667 assert_supports(OUT_ARG_DgDp_mp,j,l);
668 DgDp_mp_properties_[ j*Np() + l ] = properties;
669}
670
671
673{
674 TEUCHOS_TEST_FOR_EXCEPTION(
675 !supports_[arg], std::logic_error
676 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(arg): "
677 "model = \'"<<modelEvalDescription_<<"\': Error, "
678 "The argument arg = " << toString(arg) << " is not supported!"
679 );
680}
681
682
684{
685 assert_l(l);
686 TEUCHOS_TEST_FOR_EXCEPTION(
687 supports_DfDp_[l].none(), std::logic_error
688 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DfDp,l): "
689 "model = \'"<<modelEvalDescription_<<"\': Error,"
690 "The argument DfDp(l) with index l = " << l << " is not supported!"
691 );
692}
693
694
696{
697 assert_j(j);
698 TEUCHOS_TEST_FOR_EXCEPTION(
699 supports_DgDx_dot_[j].none(), std::logic_error
700 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDx_dot,j): "
701 "model = \'"<<modelEvalDescription_<<"\': Error,"
702 "The argument DgDx_dot(j) with index j = " << j << " is not supported!"
703 );
704}
705
706
708{
709 assert_j(j);
710 TEUCHOS_TEST_FOR_EXCEPTION(
711 supports_DgDx_dotdot_[j].none(), std::logic_error
712 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDx_dotdot,j): "
713 "model = \'"<<modelEvalDescription_<<"\': Error,"
714 "The argument DgDx_dotdot(j) with index j = " << j << " is not supported!"
715 );
716}
717
718
720{
721 assert_j(j);
722 TEUCHOS_TEST_FOR_EXCEPTION(
723 supports_DgDx_[j].none(), std::logic_error
724 ,"TEpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDx,j): "
725 "model = \'"<<modelEvalDescription_<<"\': Error,"
726 "The argument DgDx(j) with index j = " << j << " is not supported!"
727 );
728}
729
730
732{
733 assert_j(j);
734 assert_l(l);
735 TEUCHOS_TEST_FOR_EXCEPTION(
736 supports_DgDp_[ j*Np() + l ].none(), std::logic_error
737 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDp,j,l): "
738 "model = \'"<<modelEvalDescription_<<"\': Error,"
739 "The argument DgDp(j,l) with indexes j = " << j << " and l = " << l << " is not supported!"
740 );
741}
742
744{
745 assert_j(j);
746 TEUCHOS_TEST_FOR_EXCEPTION(
747 !supports_g_sg_[j], std::logic_error
748 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_g_sg,j): "
749 "model = \'"<<modelEvalDescription_<<"\': Error,"
750 "The argument g_sg(j) with index j = " << j << " is not supported!"
751 );
752}
753
755{
756 assert_l(l);
757 TEUCHOS_TEST_FOR_EXCEPTION(
758 supports_DfDp_sg_[l].none(), std::logic_error
759 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DfDp_sg,l): "
760 "model = \'"<<modelEvalDescription_<<"\': Error,"
761 "The argument DfDp_sg(l) with index l = " << l << " is not supported!"
762 );
763}
764
765
767{
768 assert_j(j);
769 TEUCHOS_TEST_FOR_EXCEPTION(
770 supports_DgDx_dot_sg_[j].none(), std::logic_error
771 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDx_dot_sg,j): "
772 "model = \'"<<modelEvalDescription_<<"\': Error,"
773 "The argument DgDx_dot_sg(j) with index j = " << j << " is not supported!"
774 );
775}
776
777
779{
780 assert_j(j);
781 TEUCHOS_TEST_FOR_EXCEPTION(
782 supports_DgDx_dotdot_sg_[j].none(), std::logic_error
783 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDx_dotdot_sg,j): "
784 "model = \'"<<modelEvalDescription_<<"\': Error,"
785 "The argument DgDx_dotdot_sg(j) with index j = " << j << " is not supported!"
786 );
787}
788
789
791{
792 assert_j(j);
793 TEUCHOS_TEST_FOR_EXCEPTION(
794 supports_DgDx_sg_[j].none(), std::logic_error
795 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDx_sg,j): "
796 "model = \'"<<modelEvalDescription_<<"\': Error,"
797 "The argument DgDx_sg(j) with index j = " << j << " is not supported!"
798 );
799}
800
802{
803 assert_j(j);
804 assert_l(l);
805 TEUCHOS_TEST_FOR_EXCEPTION(
806 supports_DgDp_sg_[ j*Np() + l ].none(), std::logic_error
807 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDp_sg,j,l): "
808 "model = \'"<<modelEvalDescription_<<"\': Error,"
809 "The argument DgDp_sg(j,l) with indexes j = " << j << " and l = " << l << " is not supported!"
810 );
811}
812
814{
815 assert_j(j);
816 TEUCHOS_TEST_FOR_EXCEPTION(
817 !supports_g_mp_[j], std::logic_error
818 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_g_mp,j): "
819 "model = \'"<<modelEvalDescription_<<"\': Error,"
820 "The argument g_mp(j) with index j = " << j << " is not supported!"
821 );
822}
823
825{
826 assert_l(l);
827 TEUCHOS_TEST_FOR_EXCEPTION(
828 supports_DfDp_mp_[l].none(), std::logic_error
829 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DfDp_mp,l): "
830 "model = \'"<<modelEvalDescription_<<"\': Error,"
831 "The argument DfDp_mp(l) with index l = " << l << " is not supported!"
832 );
833}
834
835
837{
838 assert_j(j);
839 TEUCHOS_TEST_FOR_EXCEPTION(
840 supports_DgDx_dot_mp_[j].none(), std::logic_error
841 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDx_dot_mp,j): "
842 "model = \'"<<modelEvalDescription_<<"\': Error,"
843 "The argument DgDx_dot_mp(j) with index j = " << j << " is not supported!"
844 );
845}
846
847
849{
850 assert_j(j);
851 TEUCHOS_TEST_FOR_EXCEPTION(
852 supports_DgDx_dotdot_mp_[j].none(), std::logic_error
853 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDx_dotdot_mp,j): "
854 "model = \'"<<modelEvalDescription_<<"\': Error,"
855 "The argument DgDx_dotdot_mp(j) with index j = " << j << " is not supported!"
856 );
857}
858
859
861{
862 assert_j(j);
863 TEUCHOS_TEST_FOR_EXCEPTION(
864 supports_DgDx_mp_[j].none(), std::logic_error
865 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDx_mp,j): "
866 "model = \'"<<modelEvalDescription_<<"\': Error,"
867 "The argument DgDx_mp(j) with index j = " << j << " is not supported!"
868 );
869}
870
872{
873 assert_j(j);
874 assert_l(l);
875 TEUCHOS_TEST_FOR_EXCEPTION(
876 supports_DgDp_mp_[ j*Np() + l ].none(), std::logic_error
877 ,"EpetraExt::ModelEvaluator::OutArgs::assert_supports(OUT_ARG_DgDp_mp,j,l): "
878 "model = \'"<<modelEvalDescription_<<"\': Error,"
879 "The argument DgDp_mp(j,l) with indexes j = " << j << " and l = " << l << " is not supported!"
880 );
881}
882
883
885{
886 TEUCHOS_TEST_FOR_EXCEPTION(
887 Np()==0, std::logic_error
888 ,"EpetraExt::ModelEvaluator::OutArgs::assert_l(l): model = \'"<<modelEvalDescription_<<"\': Error, "
889 "no auxiliary parameters subvectors p(l) are supported!!"
890 );
891 TEUCHOS_TEST_FOR_EXCEPTION(
892 !( 0 <= l && l < Np() ), std::logic_error
893 ,"EpetraExt::ModelEvaluator::OutArgs::assert_l(l): "
894 "model = \'"<<modelEvalDescription_<<"\': Error, "
895 "The parameter subvector p(l) index l = " << l << " is not in the range [0,"<<Np()-1<<"]!"
896 );
897}
898
899
901{
902 TEUCHOS_TEST_FOR_EXCEPTION(
903 Ng()==0, std::logic_error
904 ,"EpetraExt::ModelEvaluator::OutArgs::assert_j(j): model = \'"<<modelEvalDescription_<<"\': Error, "
905 "no auxiliary functions g(j) are supported!!"
906 );
907 TEUCHOS_TEST_FOR_EXCEPTION(
908 !( 0 <= j && j < Ng() ), std::logic_error
909 ,"EpetraExt::ModelEvaluator::OutArgs::assert_j(j): model = \'"<<modelEvalDescription_<<"\': Error, "
910 "The auxiliary function g(j) index j = " << j << " is not in the range [0,"<<Ng()-1<<"]!"
911 );
912}
913
914
915//
916// ModelEvaluator
917//
918
919
920// Destructor
921
922
924{}
925
926
927// Vector maps
928
929
930Teuchos::RCP<const Epetra_Map>
932{ return Teuchos::null; }
933
934Teuchos::RCP<const Teuchos::Array<std::string> >
936{ return Teuchos::null; }
937
938Teuchos::RCP<const Epetra_Map>
940{ return Teuchos::null; }
941
942Teuchos::ArrayView<const std::string>
944{ return Teuchos::null; }
945
946
947// Initial guesses for variables/parameters
948
949
950Teuchos::RCP<const Epetra_Vector>
952{ return Teuchos::null; }
953
954Teuchos::RCP<const Epetra_Vector>
956{ return Teuchos::null; }
957
958Teuchos::RCP<const Epetra_Vector>
960{ return Teuchos::null; }
961
962Teuchos::RCP<const Epetra_Vector>
964{ return Teuchos::null; }
965
967{ return 0.0; }
968
969
970// Bounds for variables/parameters
971
972
974{
975 return 1e+50;
976}
977
978
979Teuchos::RCP<const Epetra_Vector>
981{ return Teuchos::null; }
982
983
984Teuchos::RCP<const Epetra_Vector>
986{ return Teuchos::null; }
987
988
989Teuchos::RCP<const Epetra_Vector>
991{ return Teuchos::null; }
992
993
994Teuchos::RCP<const Epetra_Vector>
996{ return Teuchos::null; }
997
998
1000{ return 0.0; }
1001
1002
1004{ return 0.0; }
1005
1006
1007// Factory functions for creating derivative objects
1008
1009
1010Teuchos::RCP<Epetra_Operator>
1012{ return Teuchos::null; }
1013
1014Teuchos::RCP<EpetraExt::ModelEvaluator::Preconditioner>
1016{ return Teuchos::null; }
1017
1018Teuchos::RCP<Epetra_Operator>
1020{ return Teuchos::null; }
1021
1022Teuchos::RCP<Epetra_Operator>
1024{ return Teuchos::null; }
1025
1026Teuchos::RCP<Epetra_Operator>
1028{ return Teuchos::null; }
1029
1030Teuchos::RCP<Epetra_Operator>
1032{ return Teuchos::null; }
1033
1034Teuchos::RCP<Epetra_Operator>
1035ModelEvaluator::create_DgDp_op( int /* j */, int /* l */ ) const
1036{ return Teuchos::null; }
1037
1038} // namespace EpetraExt
1039
1040
1041//
1042// Helper functions
1043//
1044
1045
1048 )
1049{
1050 switch(orientation) {
1052 return "DERIV_MV_BY_COL";
1054 return "DERIV_TRANS_MV_BY_ROW";
1055 default:
1056 TEUCHOS_TEST_FOR_EXCEPT(true);
1057 }
1058 TEUCHOS_UNREACHABLE_RETURN(""); // Should never be called
1059}
1060
1061
1063{
1064 switch(inArg) {
1066 return "IN_ARG_x_dot";
1068 return "IN_ARG_x_dotdot";
1070 return "IN_ARG_x";
1072 return "IN_ARG_x_dot_poly";
1074 return "IN_ARG_x_dotdot_poly";
1076 return "IN_ARG_x_poly";
1078 return "IN_ARG_x_dot_sg";
1080 return "IN_ARG_x_dotdot_sg";
1082 return "IN_ARG_x_sg";
1084 return "IN_ARG_x_dot_mp";
1086 return "IN_ARG_x_dotdot_mp";
1088 return "IN_ARG_x_mp";
1090 return "IN_ARG_t";
1092 return "IN_ARG_alpha";
1094 return "IN_ARG_omega";
1096 return "IN_ARG_beta";
1098 return "IN_ARG_step_size";
1100 return "IN_ARG_stage_number";
1101 default:
1102 TEUCHOS_TEST_FOR_EXCEPT("Invalid inArg!");
1103 }
1104 TEUCHOS_UNREACHABLE_RETURN(""); // Will never be executed!
1105}
1106
1107
1109{
1110 switch(outArg) {
1112 return "OUT_ARG_f";
1114 return "OUT_ARG_W";
1116 return "OUT_ARG_WPrec";
1118 return "OUT_ARG_f_poly";
1120 return "OUT_ARG_f_sg";
1122 return "OUT_ARG_W_sg";
1124 return "OUT_ARG_f_mp";
1126 return "OUT_ARG_W_mp";
1127 default:
1128 TEUCHOS_TEST_FOR_EXCEPT("Invalid outArg!");
1129 }
1130 TEUCHOS_UNREACHABLE_RETURN(""); // Will never be executed!
1131}
1132
1133
1134Teuchos::RCP<Epetra_Operator>
1136 const std::string &modelEvalDescription,
1137 const ModelEvaluator::Derivative &deriv,
1138 const std::string &derivName
1139 )
1140{
1141 TEUCHOS_TEST_FOR_EXCEPTION(
1142 deriv.getMultiVector().get() != NULL, std::logic_error
1143 ,"For model \'" << modelEvalDescription << "\' the derivative \'"
1144 << derivName << "\' is of type Epetra_MultiVector and not of type Epetra_Operator!"
1145 );
1146 return deriv.getLinearOp();
1147}
1148
1149
1150Teuchos::RCP<Epetra_MultiVector>
1152 const std::string &modelEvalDescription,
1153 const ModelEvaluator::Derivative &deriv,
1154 const std::string &derivName,
1156 )
1157{
1158 TEUCHOS_TEST_FOR_EXCEPTION(
1159 deriv.getLinearOp().get() != NULL, std::logic_error
1160 ,"For model \'" << modelEvalDescription << "\' the derivative \'"
1161 << derivName << "\' is of type Epetra_Operator and not of type Epetra_MultiVector!"
1162 );
1163 Teuchos::RCP<Epetra_MultiVector>
1164 mv = deriv.getMultiVector();
1165 if(mv.get()) {
1166 TEUCHOS_TEST_FOR_EXCEPTION(
1167 deriv.getMultiVectorOrientation()!=mvOrientation, std::logic_error
1168 ,"For model \'" << modelEvalDescription << "\' the derivative \'"
1169 << derivName << "\' if not the orientation \'" << toString(mvOrientation)
1170 << "\'"
1171 );
1172 }
1173 return mv;
1174}
1175
1176
1177Teuchos::RCP<Epetra_Operator>
1179 const int l,
1180 const ModelEvaluator::OutArgs &outArgs
1181 )
1182{
1183 std::ostringstream derivName; derivName << "DfDp("<<l<<")";
1184 return getLinearOp(
1185 outArgs.modelEvalDescription()
1186 ,outArgs.get_DfDp(l)
1187 ,derivName.str()
1188 );
1189}
1190
1191
1192Teuchos::RCP<Epetra_MultiVector>
1194 const int l,
1195 const ModelEvaluator::OutArgs &outArgs
1196 )
1197{
1198 std::ostringstream derivName; derivName << "DfDp("<<l<<")";
1199 return getMultiVector(
1200 outArgs.modelEvalDescription()
1201 ,outArgs.get_DfDp(l)
1202 ,derivName.str()
1204 );
1205}
1206
1207
1208Teuchos::RCP<Epetra_MultiVector>
1210 const int j,
1211 const ModelEvaluator::OutArgs &outArgs,
1213 )
1214{
1215 std::ostringstream derivName; derivName << "DgDx_dot("<<j<<")";
1216 return getMultiVector(
1217 outArgs.modelEvalDescription(),
1218 outArgs.get_DgDx_dot(j),
1219 derivName.str(),
1220 mvOrientation
1221 );
1222}
1223
1224
1225Teuchos::RCP<Epetra_MultiVector>
1227 const int j,
1228 const ModelEvaluator::OutArgs &outArgs,
1230 )
1231{
1232 std::ostringstream derivName; derivName << "DgDx_dotdot("<<j<<")";
1233 return getMultiVector(
1234 outArgs.modelEvalDescription(),
1235 outArgs.get_DgDx_dotdot(j),
1236 derivName.str(),
1237 mvOrientation
1238 );
1239}
1240
1241
1242Teuchos::RCP<Epetra_MultiVector>
1244 const int j,
1245 const ModelEvaluator::OutArgs &outArgs,
1247 )
1248{
1249 std::ostringstream derivName; derivName << "DgDx("<<j<<")";
1250 return getMultiVector(
1251 outArgs.modelEvalDescription(),
1252 outArgs.get_DgDx(j),
1253 derivName.str(),
1254 mvOrientation
1255 );
1256}
1257
1258
1259Teuchos::RCP<Epetra_MultiVector>
1261 const int j,
1262 const int l,
1263 const ModelEvaluator::OutArgs &outArgs,
1265 )
1266{
1267 std::ostringstream derivName; derivName << "DgDp("<<j<<","<<l<<")";
1268 return getMultiVector(
1269 outArgs.modelEvalDescription(),
1270 outArgs.get_DgDp(j,l),
1271 derivName.str(),
1272 mvOrientation
1273 );
1274}
Simple aggregate class that stores a derivative object as a general linear operator or as a multi-vec...
Teuchos::RCP< Epetra_MultiVector > getMultiVector() const
Teuchos::RCP< Epetra_Operator > getLinearOp() const
EDerivativeMultiVectorOrientation getMultiVectorOrientation() const
bool supports(EInArgsMembers arg) const
void assert_supports(EInArgsMembers arg) const
void _setSupports(EInArgsMembers arg, bool supports)
Simple aggregate class that stores a derivative object as a general linear operator or as a multi-vec...
void _set_DgDp_mp_properties(int j, int l, const DerivativeProperties &properties)
bool supports(EOutArgsMembers arg) const
bool funcOrDerivesAreSet(EOutArgsMembers arg) const
Return true if the function or its derivatives are set.
void _set_W_properties(const DerivativeProperties &W_properties)
void _set_DgDx_dotdot_properties(int j, const DerivativeProperties &properties)
void _set_DgDx_mp_properties(int j, const DerivativeProperties &properties)
void _set_DgDx_dot_sg_properties(int j, const DerivativeProperties &properties)
void _set_DgDp_sg_properties(int j, int l, const DerivativeProperties &properties)
void setFailed() const
Set that the evaluation as a whole failed.
void assert_supports(EOutArgsMembers arg) const
void _set_DfDp_properties(int l, const DerivativeProperties &properties)
void _set_DgDx_dot_properties(int j, const DerivativeProperties &properties)
void _setModelEvalDescription(const std::string &modelEvalDescription)
void _set_DgDx_dotdot_mp_properties(int j, const DerivativeProperties &properties)
void _set_DgDx_properties(int j, const DerivativeProperties &properties)
void _set_DgDx_sg_properties(int j, const DerivativeProperties &properties)
void _set_DgDx_dot_mp_properties(int j, const DerivativeProperties &properties)
void _set_DfDp_sg_properties(int l, const DerivativeProperties &properties)
void _set_DgDx_dotdot_sg_properties(int j, const DerivativeProperties &properties)
void _set_WPrec_properties(const DerivativeProperties &WPrec_properties)
void _setSupports(EOutArgsMembers arg, bool supports)
Derivative get_DgDp(int j, int l) const
void _set_DfDp_mp_properties(int l, const DerivativeProperties &properties)
bool isFailed() const
Return if the evaluation failed or not.
void _set_DgDp_properties(int j, int l, const DerivativeProperties &properties)
Simple aggregate class that stores a derivative object as a general linear operator or as a multi-vec...
virtual double get_t_upper_bound() const
virtual Teuchos::RCP< const Epetra_Vector > get_p_upper_bounds(int l) const
virtual Teuchos::RCP< Epetra_Operator > create_DfDp_op(int l) const
virtual Teuchos::RCP< Epetra_Operator > create_DgDp_op(int j, int l) const
virtual double get_t_lower_bound() const
@ IN_ARG_x_sg
Stochastic Galerkin solution vector polynomial.
@ IN_ARG_x_dotdot_sg
Stochastic Galerkin time second derivative vector polynomial.
@ IN_ARG_x_dot_mp
Multi-point time derivative vector.
@ IN_ARG_x_poly
Solution vector Taylor polynomial.
@ IN_ARG_x_mp
Multi-point solution vector.
@ IN_ARG_x_dot_sg
Stochastic Galerkin time derivative vector polynomial.
@ IN_ARG_x_dotdot_mp
Multi-point time second derivative vector.
@ IN_ARG_x_dot_poly
Time derivative vector Taylor polynomial.
@ IN_ARG_x_dotdot_poly
Time second derivative vector Taylor polynomial.
@ IN_ARG_omega
Coeff of second derivative term d(x_dotdot)/dx.
virtual Teuchos::RCP< EpetraExt::ModelEvaluator::Preconditioner > create_WPrec() const
virtual Teuchos::RCP< const Epetra_Vector > get_x_lower_bounds() const
virtual Teuchos::RCP< const Epetra_Map > get_g_map(int j) const
\breif .
virtual Teuchos::RCP< const Epetra_Vector > get_x_dotdot_init() const
virtual Teuchos::RCP< Epetra_Operator > create_DgDx_op(int j) const
virtual Teuchos::ArrayView< const std::string > get_g_names(int j) const
Get the names of the response functions associated with response subvector j if available.
@ OUT_ARG_f_mp
Multi-point residual vector.
@ OUT_ARG_W_sg
Stochastic Galerkin "W" operator polyomial.
@ OUT_ARG_f_poly
Residual vector Taylor polynomial.
@ OUT_ARG_WPrec
Preconditioner operator (approx Jacobian)
@ OUT_ARG_W_mp
Multi-point "W" operator.
@ OUT_ARG_f_sg
Stochastic Galerkin residual vector polynomial.
virtual Teuchos::RCP< Epetra_Operator > create_W() const
If supported, create a Epetra_Operator object for W to be evaluated.
virtual Teuchos::RCP< const Epetra_Vector > get_p_lower_bounds(int l) const
virtual Teuchos::RCP< const Epetra_Vector > get_x_upper_bounds() const
virtual Teuchos::RCP< const Teuchos::Array< std::string > > get_p_names(int l) const
Get the names of the parameters associated with parameter subvector l if available.
virtual Teuchos::RCP< const Epetra_Vector > get_x_dot_init() const
virtual Teuchos::RCP< Epetra_Operator > create_DgDx_dot_op(int j) const
virtual Teuchos::RCP< const Epetra_Vector > get_p_init(int l) const
virtual double getInfBound() const
Return the value of an infinite bound.
virtual Teuchos::RCP< const Epetra_Map > get_p_map(int l) const
\breif .
virtual Teuchos::RCP< const Epetra_Vector > get_x_init() const
virtual Teuchos::RCP< Epetra_Operator > create_DgDx_dotdot_op(int j) const
EpetraExt::BlockCrsMatrix: A class for constructing a distributed block matrix.
Teuchos::RCP< Epetra_MultiVector > get_DgDx_dot_mv(const int j, const ModelEvaluator::OutArgs &outArgs, const ModelEvaluator::EDerivativeMultiVectorOrientation mvOrientation)
Teuchos::RCP< Epetra_Operator > getLinearOp(const std::string &modelEvalDescription, const ModelEvaluator::Derivative &deriv, const std::string &derivName)
Teuchos::RCP< Epetra_Operator > get_DfDp_op(const int l, const ModelEvaluator::OutArgs &outArgs)
Teuchos::RCP< Epetra_MultiVector > get_DgDp_mv(const int j, const int l, const ModelEvaluator::OutArgs &outArgs, const ModelEvaluator::EDerivativeMultiVectorOrientation mvOrientation)
Teuchos::RCP< Epetra_MultiVector > get_DgDx_mv(const int j, const ModelEvaluator::OutArgs &outArgs, const ModelEvaluator::EDerivativeMultiVectorOrientation mvOrientation)
Teuchos::RCP< Epetra_MultiVector > get_DfDp_mv(const int l, const ModelEvaluator::OutArgs &outArgs)
Teuchos::RCP< Epetra_MultiVector > get_DgDx_dotdot_mv(const int j, const ModelEvaluator::OutArgs &outArgs, const ModelEvaluator::EDerivativeMultiVectorOrientation mvOrientation)
std::string toString(const int &x)
Teuchos::RCP< Epetra_MultiVector > getMultiVector(const std::string &modelEvalDescription, const ModelEvaluator::Derivative &deriv, const std::string &derivName, const ModelEvaluator::EDerivativeMultiVectorOrientation mvOrientation)