Tempus  Version of the Day
Time Integration
CDR_Model_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 NOX_THYRA_MODEL_EVALUATOR_1DFEM_DEF_HPP
10 #define NOX_THYRA_MODEL_EVALUATOR_1DFEM_DEF_HPP
11 
12 // Thyra support
13 #include "Thyra_DefaultSpmdVectorSpace.hpp"
14 #include "Thyra_DefaultSerialDenseLinearOpWithSolveFactory.hpp"
15 #include "Thyra_DetachedMultiVectorView.hpp"
16 #include "Thyra_DetachedVectorView.hpp"
17 #include "Thyra_MultiVectorStdOps.hpp"
18 #include "Thyra_VectorStdOps.hpp"
19 #include "Thyra_PreconditionerBase.hpp"
20 
21 // Epetra support
22 #include "Thyra_EpetraThyraWrappers.hpp"
23 #include "Thyra_EpetraLinearOp.hpp"
24 #include "Thyra_get_Epetra_Operator.hpp"
25 #include "Epetra_Comm.h"
26 #include "Epetra_Map.h"
27 #include "Epetra_Vector.h"
28 #include "Epetra_Import.h"
29 #include "Epetra_CrsGraph.h"
30 #include "Epetra_CrsMatrix.h"
31 
32 namespace Tempus_Test {
33 
34 // Constructor
35 
36 template<class Scalar>
37 CDR_Model<Scalar>::
38 CDR_Model(const Teuchos::RCP<const Epetra_Comm>& comm,
39  const int num_global_elements,
40  const Scalar z_min,
41  const Scalar z_max,
42  const Scalar a,
43  const Scalar k) :
44  comm_(comm),
45  num_global_elements_(num_global_elements),
46  z_min_(z_min),
47  z_max_(z_max),
48  a_(a),
49  k_(k),
50  showGetInvalidArg_(false)
51 {
52  using Teuchos::RCP;
53  using Teuchos::rcp;
54  using ::Thyra::VectorBase;
55  typedef ::Thyra::ModelEvaluatorBase MEB;
56  typedef Teuchos::ScalarTraits<Scalar> ST;
57 
58  TEUCHOS_ASSERT(nonnull(comm_));
59 
60  const int num_nodes = num_global_elements_ + 1;
61 
62  // owned space
63  x_owned_map_ = rcp(new Epetra_Map(num_nodes,0,*comm_));
64  x_space_ = ::Thyra::create_VectorSpace(x_owned_map_);
65 
66  // ghosted space
67  if (comm_->NumProc() == 1) {
68  x_ghosted_map_ = x_owned_map_;
69  } else {
70 
71  int OverlapNumMyElements;
72  int OverlapMinMyGID;
73  OverlapNumMyElements = x_owned_map_->NumMyElements() + 2;
74  if ( (comm_->MyPID() == 0) || (comm_->MyPID() == (comm_->NumProc() - 1)) )
75  OverlapNumMyElements --;
76 
77  if (comm_->MyPID() == 0)
78  OverlapMinMyGID = x_owned_map_->MinMyGID();
79  else
80  OverlapMinMyGID = x_owned_map_->MinMyGID() - 1;
81 
82  int* OverlapMyGlobalElements = new int[OverlapNumMyElements];
83 
84  for (int i = 0; i < OverlapNumMyElements; i ++)
85  OverlapMyGlobalElements[i] = OverlapMinMyGID + i;
86 
87  x_ghosted_map_ =
88  Teuchos::rcp(new Epetra_Map(-1,
89  OverlapNumMyElements,
90  OverlapMyGlobalElements,
91  0,
92  *comm_));
93 
94  delete [] OverlapMyGlobalElements;
95 
96  }
97 
98  importer_ = Teuchos::rcp(new Epetra_Import(*x_ghosted_map_, *x_owned_map_));
99 
100  // residual space
101  f_owned_map_ = x_owned_map_;
102  f_space_ = x_space_;
103 
104  x0_ = ::Thyra::createMember(x_space_);
105  V_S(x0_.ptr(), ST::zero());
106 
107 // set_p(Teuchos::tuple<Scalar>(p0, p1)());
108 // set_x0(Teuchos::tuple<Scalar>(x0, x1)());
109 
110  // Initialize the graph for W CrsMatrix object
111  W_graph_ = createGraph();
112 
113  // Create the nodal coordinates
114  {
115  node_coordinates_ = Teuchos::rcp(new Epetra_Vector(*x_owned_map_));
116  Scalar length = z_max_ - z_min_;
117  Scalar dx = length/((double) num_global_elements_ - 1);
118  for (int i=0; i < x_owned_map_->NumMyElements(); i++) {
119  (*node_coordinates_)[i] = z_min_ + dx*((double) x_owned_map_->MinMyGID() + i);
120  }
121  }
122 
123 
124 
125  MEB::InArgsSetup<Scalar> inArgs;
126  inArgs.setModelEvalDescription(this->description());
127  inArgs.setSupports(MEB::IN_ARG_t);
128  inArgs.setSupports(MEB::IN_ARG_x);
129  inArgs.setSupports( MEB::IN_ARG_beta );
130  inArgs.setSupports( MEB::IN_ARG_x_dot );
131  inArgs.setSupports( MEB::IN_ARG_alpha );
132  prototypeInArgs_ = inArgs;
133 
134  MEB::OutArgsSetup<Scalar> outArgs;
135  outArgs.setModelEvalDescription(this->description());
136  outArgs.setSupports(MEB::OUT_ARG_f);
137  outArgs.setSupports(MEB::OUT_ARG_W);
138  outArgs.setSupports(MEB::OUT_ARG_W_op);
139  outArgs.setSupports(MEB::OUT_ARG_W_prec);
140 // outArgs.set_W_properties(DerivativeProperties(
141 // DERIV_LINEARITY_NONCONST
142 // ,DERIV_RANK_FULL
143 // ,true // supportsAdjoint
144 // ));
145  prototypeOutArgs_ = outArgs;
146 
147  // Setup nominal values
148  nominalValues_ = inArgs;
149  nominalValues_.set_x(x0_);
150  auto x_dot_init = Thyra::createMember(this->get_x_space());
151  Thyra::put_scalar(Scalar(0.0),x_dot_init.ptr());
152  nominalValues_.set_x_dot(x_dot_init);
153 }
154 
155 // Initializers/Accessors
156 
157 template<class Scalar>
158 Teuchos::RCP<Epetra_CrsGraph>
159 CDR_Model<Scalar>::createGraph()
160 {
161  Teuchos::RCP<Epetra_CrsGraph> W_graph;
162 
163  // Create the shell for the
164  W_graph = Teuchos::rcp(new Epetra_CrsGraph(Copy, *x_owned_map_, 5));
165 
166  // Declare required variables
167  int row;
168  int column;
169  int OverlapNumMyElements = x_ghosted_map_->NumMyElements();
170 
171  // Loop Over # of Finite Elements on Processor
172  for (int ne=0; ne < OverlapNumMyElements-1; ne++) {
173 
174  // Loop over Nodes in Element
175  for (int i=0; i< 2; i++) {
176  row=x_ghosted_map_->GID(ne+i);
177 
178  // Loop over Trial Functions
179  for(int j=0;j < 2; j++) {
180 
181  // If this row is owned by current processor, add the index
182  if (x_owned_map_->MyGID(row)) {
183  column=x_ghosted_map_->GID(ne+j);
184  W_graph->InsertGlobalIndices(row, 1, &column);
185  }
186  }
187  }
188  }
189  W_graph->FillComplete();
190  return W_graph;
191 }
192 
193 template<class Scalar>
194 void CDR_Model<Scalar>::set_x0(const Teuchos::ArrayView<const Scalar> &x0_in)
195 {
196 #ifdef TEUCHOS_DEBUG
197  TEUCHOS_ASSERT_EQUALITY(x_space_->dim(), x0_in.size());
198 #endif
199  Thyra::DetachedVectorView<Scalar> x0(x0_);
200  x0.sv().values()().assign(x0_in);
201 }
202 
203 
204 template<class Scalar>
205 void CDR_Model<Scalar>::setShowGetInvalidArgs(bool showGetInvalidArg)
206 {
207  showGetInvalidArg_ = showGetInvalidArg;
208 }
209 
210 template<class Scalar>
211 void CDR_Model<Scalar>::
212 set_W_factory(const Teuchos::RCP<const ::Thyra::LinearOpWithSolveFactoryBase<Scalar> >& W_factory)
213 {
214  W_factory_ = W_factory;
215 }
216 
217 // Public functions overridden from ModelEvaluator
218 
219 
220 template<class Scalar>
221 Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> >
222 CDR_Model<Scalar>::get_x_space() const
223 {
224  return x_space_;
225 }
226 
227 
228 template<class Scalar>
229 Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> >
230 CDR_Model<Scalar>::get_f_space() const
231 {
232  return f_space_;
233 }
234 
235 
236 template<class Scalar>
237 Thyra::ModelEvaluatorBase::InArgs<Scalar>
238 CDR_Model<Scalar>::getNominalValues() const
239 {
240  return nominalValues_;
241 }
242 
243 
244 template<class Scalar>
245 Teuchos::RCP<Thyra::LinearOpWithSolveBase<double> >
246 CDR_Model<Scalar>::create_W() const
247 {
248  Teuchos::RCP<const Thyra::LinearOpWithSolveFactoryBase<double> > W_factory =
249  this->get_W_factory();
250 
251  TEUCHOS_TEST_FOR_EXCEPTION(is_null(W_factory),std::runtime_error,"W_factory in CDR_Model has a null W_factory!");
252 
253  Teuchos::RCP<Thyra::LinearOpBase<double> > matrix = this->create_W_op();
254 
255  Teuchos::RCP<Thyra::LinearOpWithSolveBase<double> > W =
256  Thyra::linearOpWithSolve<double>(*W_factory,matrix);
257 
258  return W;
259 }
260 
261 template<class Scalar>
262 Teuchos::RCP<Thyra::LinearOpBase<Scalar> >
263 CDR_Model<Scalar>::create_W_op() const
264 {
265  Teuchos::RCP<Epetra_CrsMatrix> W_epetra =
266  Teuchos::rcp(new Epetra_CrsMatrix(::Copy,*W_graph_));
267 
268  return Thyra::nonconstEpetraLinearOp(W_epetra);
269 }
270 
271 template<class Scalar>
272 Teuchos::RCP< ::Thyra::PreconditionerBase<Scalar> >
273 CDR_Model<Scalar>::create_W_prec() const
274 {
275  Teuchos::RCP<Epetra_CrsMatrix> W_epetra =
276  Teuchos::rcp(new Epetra_CrsMatrix(::Copy,*W_graph_));
277 
278  const Teuchos::RCP<Thyra::LinearOpBase< Scalar > > W_op =
279  Thyra::nonconstEpetraLinearOp(W_epetra);
280 
281  Teuchos::RCP<Thyra::DefaultPreconditioner<Scalar> > prec =
282  Teuchos::rcp(new Thyra::DefaultPreconditioner<Scalar>);
283 
284  prec->initializeRight(W_op);
285 
286  return prec;
287 }
288 
289 template<class Scalar>
290 Teuchos::RCP<const Thyra::LinearOpWithSolveFactoryBase<Scalar> >
291 CDR_Model<Scalar>::get_W_factory() const
292 {
293  return W_factory_;
294 }
295 
296 
297 template<class Scalar>
298 Thyra::ModelEvaluatorBase::InArgs<Scalar>
299 CDR_Model<Scalar>::createInArgs() const
300 {
301  return prototypeInArgs_;
302 }
303 
304 
305 // Private functions overridden from ModelEvaluatorDefaultBase
306 
307 
308 template<class Scalar>
309 Thyra::ModelEvaluatorBase::OutArgs<Scalar>
310 CDR_Model<Scalar>::createOutArgsImpl() const
311 {
312  return prototypeOutArgs_;
313 }
314 
315 
316 template<class Scalar>
317 void CDR_Model<Scalar>::evalModelImpl(
318  const Thyra::ModelEvaluatorBase::InArgs<Scalar> &inArgs,
319  const Thyra::ModelEvaluatorBase::OutArgs<Scalar> &outArgs
320  ) const
321 {
322  using Teuchos::RCP;
323  using Teuchos::rcp;
324  using Teuchos::rcp_dynamic_cast;
325 
326  TEUCHOS_ASSERT(nonnull(inArgs.get_x()));
327  TEUCHOS_ASSERT(nonnull(inArgs.get_x_dot()));
328 
329  //const Thyra::ConstDetachedVectorView<Scalar> x(inArgs.get_x());
330 
331  const RCP<Thyra::VectorBase<Scalar> > f_out = outArgs.get_f();
332  const RCP<Thyra::LinearOpBase<Scalar> > W_out = outArgs.get_W_op();
333  const RCP<Thyra::PreconditionerBase<Scalar> > W_prec_out = outArgs.get_W_prec();
334 
335 
336  if ( nonnull(f_out) || nonnull(W_out) || nonnull(W_prec_out) ) {
337 
338  // ****************
339  // Get the underlying epetra objects
340  // ****************
341 
342  RCP<Epetra_Vector> f;
343  if (nonnull(f_out)) {
344  f = Thyra::get_Epetra_Vector(*f_owned_map_,outArgs.get_f());
345  }
346 
347  RCP<Epetra_CrsMatrix> J;
348  if (nonnull(W_out)) {
349  RCP<Epetra_Operator> W_epetra = Thyra::get_Epetra_Operator(*W_out);
350  J = rcp_dynamic_cast<Epetra_CrsMatrix>(W_epetra);
351  TEUCHOS_ASSERT(nonnull(J));
352  }
353 
354  RCP<Epetra_CrsMatrix> M_inv;
355  if (nonnull(W_prec_out)) {
356  RCP<Epetra_Operator> M_epetra = Thyra::get_Epetra_Operator(*(W_prec_out->getNonconstRightPrecOp()));
357  M_inv = rcp_dynamic_cast<Epetra_CrsMatrix>(M_epetra);
358  TEUCHOS_ASSERT(nonnull(M_inv));
359  J_diagonal_ = Teuchos::rcp(new Epetra_Vector(*x_owned_map_));
360  }
361 
362  // ****************
363  // Create ghosted objects
364  // ****************
365 
366  if (is_null(u_ptr))
367  u_ptr = Teuchos::rcp(new Epetra_Vector(*x_ghosted_map_));
368 
369  u_ptr->Import(*(Thyra::get_Epetra_Vector(*x_owned_map_,inArgs.get_x())), *importer_, Insert);
370 
371  if (is_null(u_dot_ptr))
372  u_dot_ptr = Teuchos::rcp(new Epetra_Vector(*x_ghosted_map_));
373 
374  u_dot_ptr->Import(*(Thyra::get_Epetra_Vector(*x_owned_map_,inArgs.get_x_dot())), *importer_, Insert);
375 
376  if (is_null(x_ptr)) {
377  x_ptr = Teuchos::rcp(new Epetra_Vector(*x_ghosted_map_));
378  x_ptr->Import(*node_coordinates_, *importer_, Insert);
379  }
380 
381  Epetra_Vector& u = *u_ptr;
382  Epetra_Vector& u_dot = *u_dot_ptr;
383  Epetra_Vector& x = *x_ptr;
384 
385  int ierr = 0;
386  int OverlapNumMyElements = x_ghosted_map_->NumMyElements();
387 
388  double xx[2];
389  double uu[2];
390  double uu_dot[2];
391  Basis basis;
392  const auto alpha = inArgs.get_alpha();
393  const auto beta = inArgs.get_beta();
394 
395  // Zero out the objects that will be filled
396  if (nonnull(f))
397  f->PutScalar(0.0);
398  if (nonnull(J))
399  J->PutScalar(0.0);
400  if (nonnull(M_inv))
401  M_inv->PutScalar(0.0);
402 
403  // Loop Over # of Finite Elements on Processor
404  for (int ne=0; ne < OverlapNumMyElements-1; ne++) {
405 
406  // Loop Over Gauss Points
407  for(int gp=0; gp < 2; gp++) {
408  // Get the solution and coordinates at the nodes
409  xx[0]=x[ne];
410  xx[1]=x[ne+1];
411  uu[0]=u[ne];
412  uu[1]=u[ne+1];
413  uu_dot[0]=u_dot[ne];
414  uu_dot[1]=u_dot[ne+1];
415  // Calculate the basis function at the gauss point
416  basis.computeBasis(gp, xx, uu, uu_dot);
417 
418  // Loop over Nodes in Element
419  for (int i=0; i< 2; i++) {
420  int row=x_ghosted_map_->GID(ne+i);
421  //printf("Proc=%d GlobalRow=%d LocalRow=%d Owned=%d\n",
422  // MyPID, row, ne+i,x_owned_map_.MyGID(row));
423  if (x_owned_map_->MyGID(row)) {
424  if (nonnull(f)) {
425  (*f)[x_owned_map_->LID(x_ghosted_map_->GID(ne+i))]+=
426  +basis.wt*basis.dz
427  *( basis.uu_dot*basis.phi[i] //transient
428  +(a_/basis.dz*basis.duu*basis.phi[i] // convection
429  +1.0/(basis.dz*basis.dz))*basis.duu*basis.dphide[i] // diffusion
430  +k_*basis.uu*basis.uu*basis.phi[i] ); // source
431  }
432  }
433  // Loop over Trial Functions
434  if (nonnull(J)) {
435  for(int j=0;j < 2; j++) {
436  if (x_owned_map_->MyGID(row)) {
437  int column=x_ghosted_map_->GID(ne+j);
438  double jac=
439  basis.wt*basis.dz*(
440  alpha * basis.phi[i] * basis.phi[j] // transient
441  + beta * (
442  +a_/basis.dz*basis.dphide[j]*basis.phi[i] // convection
443  +(1.0/(basis.dz*basis.dz))*basis.dphide[j]*basis.dphide[i] // diffusion
444  +2.0*k_*basis.uu*basis.phi[j]*basis.phi[i] // source
445  )
446  );
447  ierr=J->SumIntoGlobalValues(row, 1, &jac, &column);
448  }
449  }
450  }
451  if (nonnull(M_inv)) {
452  for(int j=0;j < 2; j++) {
453  if (x_owned_map_->MyGID(row)) {
454  int column=x_ghosted_map_->GID(ne+j);
455  // The prec will be the diagonal of J. No need to assemble the other entries
456  if (row == column) {
457  double jac=
458  basis.wt*basis.dz*(
459  alpha * basis.phi[i] * basis.phi[j] // transient
460  + beta * (
461  +a_/basis.dz*basis.dphide[j]*basis.phi[i] // convection
462  +(1.0/(basis.dz*basis.dz))*basis.dphide[j]*basis.dphide[i] // diffusion
463  +2.0*k_*basis.uu*basis.phi[j]*basis.phi[i] // source
464  )
465  );
466  ierr = M_inv->SumIntoGlobalValues(row, 1, &jac, &column);
467  }
468  }
469  }
470  }
471  }
472  }
473  }
474 
475  // Insert Boundary Conditions and modify Jacobian and function (F)
476  // U(0)=1
477  if (comm_->MyPID() == 0) {
478  if (nonnull(f))
479  (*f)[0]= u[0] - 1.0;
480  if (nonnull(J)) {
481  int column=0;
482  double jac=1.0;
483  ierr = J->ReplaceGlobalValues(0, 1, &jac, &column);
484  column=1;
485  jac=0.0;
486  ierr = J->ReplaceGlobalValues(0, 1, &jac, &column);
487  }
488  if (nonnull(M_inv)) {
489  int column=0;
490  double jac=1.0;
491  ierr = M_inv->ReplaceGlobalValues(0, 1, &jac, &column);
492  column=1;
493  jac=0.0;
494  ierr = M_inv->ReplaceGlobalValues(0, 1, &jac, &column);
495  }
496  }
497 
498  if (nonnull(J))
499  J->FillComplete();
500 
501  if (nonnull(M_inv)) {
502  // invert the Jacobian diagonal for the preconditioner
503  M_inv->ExtractDiagonalCopy(*J_diagonal_);
504 
505  for (int i=0; i < J_diagonal_->MyLength(); ++i)
506  (*J_diagonal_)[i] = 1.0 / ((*J_diagonal_)[i]);
507 
508  M_inv->PutScalar(0.0);
509  M_inv->ReplaceDiagonalValues(*J_diagonal_);
510  M_inv->FillComplete();
511  }
512 
513  TEUCHOS_ASSERT(ierr > -1);
514 
515  }
516 
517 }
518 
519 //====================================================================
520 // Basis vector
521 
522 // Constructor
523 Basis::Basis():
524  uu(0.0),
525  zz(0.0),
526  duu(0.0),
527  eta(0.0),
528  wt(0.0),
529  dz(0.0),
530  uu_dot(0.0),
531  duu_dot(0.0)
532 {
533  phi = new double[2];
534  dphide = new double[2];
535 }
536 
537 // Destructor
538 Basis::~Basis() {
539  delete [] phi;
540  delete [] dphide;
541 }
542 
543 // Calculates a linear 1D basis
544 void Basis::computeBasis(int gp, double *z, double *u, double *u_dot) {
545  int N = 2;
546  if (gp==0) {eta=-1.0/sqrt(3.0); wt=1.0;}
547  if (gp==1) {eta=1.0/sqrt(3.0); wt=1.0;}
548 
549  // Calculate basis function and derivatives at nodel pts
550  phi[0]=(1.0-eta)/2.0;
551  phi[1]=(1.0+eta)/2.0;
552  dphide[0]=-0.5;
553  dphide[1]=0.5;
554 
555  // Caculate basis function and derivative at GP.
556  dz=0.5*(z[1]-z[0]);
557  zz=0.0;
558  uu=0.0;
559  duu=0.0;
560  uu_dot=0.0;
561  duu_dot=0.0;
562  for (int i=0; i < N; i++) {
563  zz += z[i] * phi[i];
564  uu += u[i] * phi[i];
565  duu += u[i] * dphide[i];
566  if (u_dot) {
567  uu_dot += u_dot[i] * phi[i];
568  duu_dot += u_dot[i] * dphide[i];
569  }
570  }
571 
572  return;
573 }
574 
575 } // namespace Tempus_Test
576 
577 #endif
Tempus_Test::CDR_Model::z_min_
const Scalar z_min_
Definition: CDR_Model_decl.hpp:101
Tempus_Test::CDR_Model::x0_
Teuchos::RCP< ::Thyra::VectorBase< Scalar > > x0_
Definition: CDR_Model_decl.hpp:128
Tempus_Test
Definition: Tempus_BackwardEuler_ASA.cpp:34
Tempus_Test::CDR_Model::createOutArgsImpl
::Thyra::ModelEvaluatorBase::OutArgs< Scalar > createOutArgsImpl() const
Definition: CDR_Model_impl.hpp:310
Tempus_Test::Basis::eta
double eta
Definition: CDR_Model_decl.hpp:153
Tempus_Test::CDR_Model::comm_
const Teuchos::RCP< const Epetra_Comm > comm_
Definition: CDR_Model_decl.hpp:99
Tempus_Test::Basis::zz
double zz
Definition: CDR_Model_decl.hpp:153
Tempus_Test::CDR_Model::num_global_elements_
const int num_global_elements_
Definition: CDR_Model_decl.hpp:100
Tempus_Test::Basis::computeBasis
void computeBasis(int gp, double *z, double *u, double *u_dot=nullptr)
Definition: CDR_Model_impl.hpp:544
Tempus_Test::CDR_Model::create_W
Teuchos::RCP< Thyra::LinearOpWithSolveBase< double > > create_W() const
Definition: CDR_Model_impl.hpp:246
Tempus_Test::CDR_Model::set_W_factory
void set_W_factory(const Teuchos::RCP< const ::Thyra::LinearOpWithSolveFactoryBase< Scalar > > &W_factory)
Definition: CDR_Model_impl.hpp:212
Tempus_Test::CDR_Model::node_coordinates_
Teuchos::RCP< Epetra_Vector > node_coordinates_
Definition: CDR_Model_decl.hpp:118
Tempus_Test::CDR_Model::getNominalValues
::Thyra::ModelEvaluatorBase::InArgs< Scalar > getNominalValues() const
Definition: CDR_Model_impl.hpp:238
Tempus_Test::CDR_Model::prototypeOutArgs_
::Thyra::ModelEvaluatorBase::OutArgs< Scalar > prototypeOutArgs_
Definition: CDR_Model_decl.hpp:132
Tempus_Test::CDR_Model::evalModelImpl
void evalModelImpl(const ::Thyra::ModelEvaluatorBase::InArgs< Scalar > &inArgs, const ::Thyra::ModelEvaluatorBase::OutArgs< Scalar > &outArgs) const
Definition: CDR_Model_impl.hpp:317
Tempus_Test::CDR_Model::get_x_space
Teuchos::RCP< const ::Thyra::VectorSpaceBase< Scalar > > get_x_space() const
Definition: CDR_Model_impl.hpp:222
Tempus_Test::CDR_Model::nominalValues_
::Thyra::ModelEvaluatorBase::InArgs< Scalar > nominalValues_
Definition: CDR_Model_decl.hpp:127
Tempus_Test::CDR_Model::set_x0
void set_x0(const Teuchos::ArrayView< const Scalar > &x0)
Definition: CDR_Model_impl.hpp:194
Tempus_Test::Basis::duu
double duu
Definition: CDR_Model_decl.hpp:153
Tempus_Test::Basis::dz
double dz
Definition: CDR_Model_decl.hpp:154
Tempus_Test::CDR_Model::x_space_
Teuchos::RCP< const ::Thyra::VectorSpaceBase< Scalar > > x_space_
Definition: CDR_Model_decl.hpp:106
Tempus_Test::CDR_Model::z_max_
const Scalar z_max_
Definition: CDR_Model_decl.hpp:102
Tempus_Test::CDR_Model::get_f_space
Teuchos::RCP< const ::Thyra::VectorSpaceBase< Scalar > > get_f_space() const
Definition: CDR_Model_impl.hpp:230
Tempus_Test::CDR_Model::create_W_op
Teuchos::RCP< ::Thyra::LinearOpBase< Scalar > > create_W_op() const
Definition: CDR_Model_impl.hpp:263
Tempus_Test::CDR_Model::f_space_
Teuchos::RCP< const ::Thyra::VectorSpaceBase< Scalar > > f_space_
Definition: CDR_Model_decl.hpp:111
Tempus_Test::Basis::wt
double wt
Definition: CDR_Model_decl.hpp:153
Tempus_Test::CDR_Model::create_W_prec
Teuchos::RCP< ::Thyra::PreconditionerBase< Scalar > > create_W_prec() const
Definition: CDR_Model_impl.hpp:273
Tempus_Test::CDR_Model::importer_
Teuchos::RCP< const Epetra_Import > importer_
Definition: CDR_Model_decl.hpp:109
Tempus_Test::CDR_Model::get_W_factory
Teuchos::RCP< const ::Thyra::LinearOpWithSolveFactoryBase< Scalar > > get_W_factory() const
Definition: CDR_Model_impl.hpp:291
Tempus_Test::CDR_Model::prototypeInArgs_
::Thyra::ModelEvaluatorBase::InArgs< Scalar > prototypeInArgs_
Definition: CDR_Model_decl.hpp:131
Tempus_Test::Basis
Definition: CDR_Model_decl.hpp:138
Tempus_Test::CDR_Model::x_owned_map_
Teuchos::RCP< const Epetra_Map > x_owned_map_
Definition: CDR_Model_decl.hpp:107
Tempus_Test::Basis::~Basis
~Basis()
Definition: CDR_Model_impl.hpp:538
Tempus_Test::Basis::Basis
Basis()
Definition: CDR_Model_impl.hpp:523
Tempus_Test::CDR_Model::f_owned_map_
Teuchos::RCP< const Epetra_Map > f_owned_map_
Definition: CDR_Model_decl.hpp:112
Tempus_Test::Basis::phi
double * phi
Definition: CDR_Model_decl.hpp:152
Tempus_Test::Basis::dphide
double * dphide
Definition: CDR_Model_decl.hpp:152
Tempus_Test::Basis::uu_dot
double uu_dot
Definition: CDR_Model_decl.hpp:156
Tempus_Test::Basis::duu_dot
double duu_dot
Definition: CDR_Model_decl.hpp:156
Tempus_Test::CDR_Model::W_graph_
Teuchos::RCP< Epetra_CrsGraph > W_graph_
Definition: CDR_Model_decl.hpp:114
Tempus_Test::CDR_Model::createGraph
virtual Teuchos::RCP< Epetra_CrsGraph > createGraph()
Definition: CDR_Model_impl.hpp:159
Tempus_Test::CDR_Model::createInArgs
::Thyra::ModelEvaluatorBase::InArgs< Scalar > createInArgs() const
Definition: CDR_Model_impl.hpp:299
Tempus_Test::CDR_Model::CDR_Model
CDR_Model(const Teuchos::RCP< const Epetra_Comm > &comm, const int num_global_elements, const Scalar z_min, const Scalar z_max, const Scalar a, const Scalar k)
Definition: CDR_Model_impl.hpp:38
Tempus_Test::Basis::uu
double uu
Definition: CDR_Model_decl.hpp:153
Tempus_Test::CDR_Model::setShowGetInvalidArgs
void setShowGetInvalidArgs(bool showGetInvalidArg)
Definition: CDR_Model_impl.hpp:205
Tempus_Test::CDR_Model::x_ghosted_map_
Teuchos::RCP< const Epetra_Map > x_ghosted_map_
Definition: CDR_Model_decl.hpp:108