Debian Codegraph @

packages/nox/test/epetra/Thyra/ModelEvaluator2DSim_def.hpp

raw
1 /// @HEADER
2 // *****************************************************************************
3 // NOX: An Object-Oriented Nonlinear Solver Package
4 //
5 // Copyright 2002 NTESS and the NOX contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9
10
11 #ifndef NOX_THYRA_MODEL_EVALUATOR_2DSIM_DEF_HPP
12 #define NOX_THYRA_MODEL_EVALUATOR_2DSIM_DEF_HPP
13
14 // Thyra support
15 #include "Thyra_DefaultSpmdVectorSpace.hpp"
16 #include "Thyra_DefaultSerialDenseLinearOpWithSolveFactory.hpp"
17 #include "Thyra_DetachedMultiVectorView.hpp"
18 #include "Thyra_DetachedVectorView.hpp"
19 #include "Thyra_MultiVectorStdOps.hpp"
20 #include "Thyra_VectorStdOps.hpp"
21 #include "Thyra_PreconditionerBase.hpp"
22
23 // Epetra support
24 #include "Thyra_EpetraThyraWrappers.hpp"
25 #include "Thyra_get_Epetra_Operator.hpp"
26
27 // Nonmember constuctors
28
29 template<class Scalar>
30 Teuchos::RCP<ModelEvaluator2DSim<Scalar> >
31 modelEvaluator2DSim(const Teuchos::RCP<const Epetra_Comm>& comm,
32 const Scalar d,
33 const Scalar p0,
34 const Scalar p1,
35 const Scalar x0,
36 const Scalar x1)
37 {
38 return Teuchos::rcp(new ModelEvaluator2DSim<Scalar>(comm,d,p0,p1,x0,x1));
39 }
40
41 // Initializers/Accessors
42
43 template<class Scalar>
44 void ModelEvaluator2DSim<Scalar>::set_d(const Scalar &d)
45 {
46 d_ = d;
47 }
48
49
50 template<class Scalar>
51 void ModelEvaluator2DSim<Scalar>::set_p(const Teuchos::ArrayView<const Scalar> &p)
52 {
53 #ifdef TEUCHOS_DEBUG
54 TEUCHOS_ASSERT_EQUALITY(p_.size(), p.size());
55 #endif
56 p_().assign(p);
57 }
58
59
60 template<class Scalar>
61 void ModelEvaluator2DSim<Scalar>::set_x0(const Teuchos::ArrayView<const Scalar> &x0_in)
62 {
63 #ifdef TEUCHOS_DEBUG
64 TEUCHOS_ASSERT_EQUALITY(x_space_->dim(), x0_in.size());
65 #endif
66 Thyra::DetachedVectorView<Scalar> x0(x0_);
67 x0.sv().values()().assign(x0_in);
68 }
69
70
71 template<class Scalar>
72 void ModelEvaluator2DSim<Scalar>::setShowGetInvalidArgs(bool showGetInvalidArg)
73 {
74 showGetInvalidArg_ = showGetInvalidArg;
75 }
76
77 template<class Scalar>
78 void ModelEvaluator2DSim<Scalar>::
79 set_W_factory(const Teuchos::RCP<const ::Thyra::LinearOpWithSolveFactoryBase<Scalar> >& W_factory)
80 {
81 W_factory_ = W_factory;
82 }
83
84 // Public functions overridden from ModelEvaulator
85
86
87 template<class Scalar>
88 Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> >
89 ModelEvaluator2DSim<Scalar>::get_x_space() const
90 {
91 return x_space_;
92 }
93
94
95 template<class Scalar>
96 Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> >
97 ModelEvaluator2DSim<Scalar>::get_f_space() const
98 {
99 return f_space_;
100 }
101
102
103 template<class Scalar>
104 Thyra::ModelEvaluatorBase::InArgs<Scalar>
105 ModelEvaluator2DSim<Scalar>::getNominalValues() const
106 {
107 return nominalValues_;
108 }
109
110
111 template<class Scalar>
112 Teuchos::RCP<Thyra::LinearOpBase<Scalar> >
113 ModelEvaluator2DSim<Scalar>::create_W_op() const
114 {
115 Teuchos::RCP<Epetra_CrsMatrix> W_epetra =
116 Teuchos::rcp(new Epetra_CrsMatrix(::Copy,*W_graph_));
117
118 return Thyra::nonconstEpetraLinearOp(W_epetra);
119 }
120
121 template<class Scalar>
122 Teuchos::RCP< ::Thyra::PreconditionerBase<Scalar> >
123 ModelEvaluator2DSim<Scalar>::create_W_prec() const
124 {
125 Teuchos::RCP<Epetra_CrsMatrix> W_epetra =
126 Teuchos::rcp(new Epetra_CrsMatrix(::Copy,*W_graph_));
127
128 const Teuchos::RCP<Thyra::LinearOpBase< Scalar > > W_op =
129 Thyra::nonconstEpetraLinearOp(W_epetra);
130
131 Teuchos::RCP<Thyra::DefaultPreconditioner<Scalar> > prec =
132 Teuchos::rcp(new Thyra::DefaultPreconditioner<Scalar>);
133
134 prec->initializeRight(W_op);
135
136 return prec;
137 }
138
139 template<class Scalar>
140 Teuchos::RCP<const Thyra::LinearOpWithSolveFactoryBase<Scalar> >
141 ModelEvaluator2DSim<Scalar>::get_W_factory() const
142 {
143 return W_factory_;
144 }
145
146
147 template<class Scalar>
148 Thyra::ModelEvaluatorBase::InArgs<Scalar>
149 ModelEvaluator2DSim<Scalar>::createInArgs() const
150 {
151 return prototypeInArgs_;
152 }
153
154
155 // Private functions overridden from ModelEvaulatorDefaultBase
156
157
158 template<class Scalar>
159 Thyra::ModelEvaluatorBase::OutArgs<Scalar>
160 ModelEvaluator2DSim<Scalar>::createOutArgsImpl() const
161 {
162 return prototypeOutArgs_;
163 }
164
165
166 template<class Scalar>
167 void ModelEvaluator2DSim<Scalar>::evalModelImpl(
168 const Thyra::ModelEvaluatorBase::InArgs<Scalar> &inArgs,
169 const Thyra::ModelEvaluatorBase::OutArgs<Scalar> &outArgs
170 ) const
171 {
172 using Teuchos::RCP;
173 using Teuchos::rcp_dynamic_cast;
174
175 TEUCHOS_ASSERT(nonnull(inArgs.get_x()));
176
177 const Thyra::ConstDetachedVectorView<Scalar> x(inArgs.get_x());
178
179 const RCP<Thyra::VectorBase<Scalar> > f_out = outArgs.get_f();
180 const RCP<Thyra::LinearOpBase<Scalar> > W_out = outArgs.get_W_op();
181 const RCP<Thyra::PreconditionerBase<Scalar> > W_prec_out = outArgs.get_W_prec();
182
183 if (nonnull(f_out)) {
184 NOX_FUNC_TIME_MONITOR("ModelEvaluator2DSim::eval f_out");
185 const Thyra::DetachedVectorView<Scalar> f(f_out);
186 f[0] = x[0] + x[1] * x[1] - p_[0];
187 f[1] = d_ * (x[0] * x[0] - x[1] - p_[1]);
188 }
189
190 if (nonnull(W_out)) {
191 NOX_FUNC_TIME_MONITOR("ModelEvaluator2DSim::eval W_op_out");
192 RCP<Epetra_Operator> W_epetra= Thyra::get_Epetra_Operator(*W_out);
193 RCP<Epetra_CrsMatrix> W_epetracrs = rcp_dynamic_cast<Epetra_CrsMatrix>(W_epetra);
194 TEUCHOS_ASSERT(nonnull(W_epetracrs));
195 Epetra_CrsMatrix& DfDx = *W_epetracrs;
196 DfDx.PutScalar(0.0);
197 //
198 // Fill W = DfDx
199 //
200 // W = DfDx = [ 1.0, 2*x[1] ]
201 // [ 2*d*x[0], -d ]
202 //
203 double values[2];
204 int indexes[2];
205 indexes[0] = 0;
206 indexes[1] = 1;
207 // Row [0]
208 values[0] = 1.0;
209 values[1] = 2.0*x[1];
210 DfDx.SumIntoGlobalValues( 0, 2, values, indexes );
211 // Row [1]
212 values[0] = 2.0*d_*x[0];
213 values[1] = -d_;
214 DfDx.SumIntoGlobalValues( 1, 2, values, indexes );
215 }
216 if (nonnull(W_prec_out)) {
217 NOX_FUNC_TIME_MONITOR("ModelEvaluator2DSim::eval W_prec_out");
218 RCP<Epetra_Operator> W_epetra= Thyra::get_Epetra_Operator(*W_prec_out->getNonconstRightPrecOp());
219 TEUCHOS_ASSERT(nonnull(W_epetra));
220 RCP<Epetra_CrsMatrix> W_epetracrs = rcp_dynamic_cast<Epetra_CrsMatrix>(W_epetra);
221 TEUCHOS_ASSERT(nonnull(W_epetracrs));
222 Epetra_CrsMatrix& M_inv = *W_epetracrs;
223 M_inv.PutScalar(0.0);
224
225 // Jacobi (block diagonal)
226 double values[2];
227 int indexes[2];
228 indexes[0] = 0;
229 indexes[1] = 1;
230 // Row [0]
231 values[0] = 1.0;
232 values[1] = 0.0;
233 M_inv.SumIntoGlobalValues( 0, 2, values, indexes );
234 // Row [1]
235 values[0] = 0.0;
236 values[1] = -1.0/d_;
237 M_inv.SumIntoGlobalValues( 1, 2, values, indexes );
238 }
239
240 }
241
242
243 // private
244
245
246 template<class Scalar>
247 ModelEvaluator2DSim<Scalar>::ModelEvaluator2DSim(const Teuchos::RCP<const Epetra_Comm>& comm,
248 const Scalar d,
249 const Scalar p0,
250 const Scalar p1,
251 const Scalar x0,
252 const Scalar x1) :
253 epetra_comm_(comm),
254 d_(d),
255 p_(2, Teuchos::ScalarTraits<Scalar>::zero()),
256 showGetInvalidArg_(false)
257 {
258 using Teuchos::RCP;
259 using Teuchos::rcp;
260 using ::Thyra::VectorBase;
261 typedef ::Thyra::ModelEvaluatorBase MEB;
262 typedef Teuchos::ScalarTraits<Scalar> ST;
263
264 TEUCHOS_ASSERT(nonnull(epetra_comm_));
265
266 const int nx = 2;
267
268 x_epetra_map_ = rcp(new Epetra_Map(nx,0,*epetra_comm_));
269 x_space_ = ::Thyra::create_VectorSpace(x_epetra_map_);
270
271 f_epetra_map_ = x_epetra_map_;
272 f_space_ = x_space_;
273
274 x0_ = ::Thyra::createMember(x_space_);
275 V_S(x0_.ptr(), ST::zero());
276
277 set_p(Teuchos::tuple<Scalar>(p0, p1)());
278 set_x0(Teuchos::tuple<Scalar>(x0, x1)());
279
280 // Initialize the graph for W CrsMatrix object
281 W_graph_ = rcp(new Epetra_CrsGraph(::Copy,*x_epetra_map_,nx));
282 {
283 int indices[nx] = { 0, 1 };
284 for( int i = 0; i < nx; ++i )
285 W_graph_->InsertGlobalIndices(i,nx,indices);
286 }
287 W_graph_->FillComplete();
288
289 MEB::InArgsSetup<Scalar> inArgs;
290 inArgs.setModelEvalDescription(this->description());
291 inArgs.setSupports(MEB::IN_ARG_x);
292 prototypeInArgs_ = inArgs;
293
294 MEB::OutArgsSetup<Scalar> outArgs;
295 outArgs.setModelEvalDescription(this->description());
296 outArgs.setSupports(MEB::OUT_ARG_f);
297 outArgs.setSupports(MEB::OUT_ARG_W_op);
298 outArgs.setSupports(MEB::OUT_ARG_W_prec);
299 // outArgs.set_W_properties(DerivativeProperties(
300 // DERIV_LINEARITY_NONCONST
301 // ,DERIV_RANK_FULL
302 // ,true // supportsAdjoint
303 // ));
304 prototypeOutArgs_ = outArgs;
305
306 nominalValues_ = inArgs;
307 nominalValues_.set_x(x0_);
308 }
309
310 #endif