Loading [MathJax]/extensions/TeX/newcommand.js
 deal.II version GIT relicensing-2846-g6fb608615f 2025-03-15 04:10:00+00:00
\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}} \newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=} \newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]} \newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages Concepts
vector_adaptor.h
Go to the documentation of this file.
1// ------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: LGPL-2.1-or-later
4// Copyright (C) 2017 - 2023 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Part of the source code is dual licensed under Apache-2.0 WITH
9// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10// governing the source code and code contributions can be found in
11// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12//
13// ------------------------------------------------------------------------
14
15#ifndef dealii_optimization_rol_vector_adaptor_h
16#define dealii_optimization_rol_vector_adaptor_h
17
18#include <deal.II/base/config.h>
19
20#ifdef DEAL_II_TRILINOS_WITH_ROL
22
23# include <deal.II/lac/vector.h>
24
25# include <ROL_Vector.hpp>
26
27# include <limits>
28# include <type_traits>
29
30
32
38namespace Rol
39{
109 template <typename VectorType>
110 class VectorAdaptor : public ROL::Vector<typename VectorType::value_type>
111 {
115 using size_type = typename VectorType::size_type;
116
120 using value_type = typename VectorType::value_type;
121
125 using real_type = typename VectorType::real_type;
126
127 static_assert(std::is_convertible_v<real_type, value_type>,
128 "The real_type of the current VectorType is not "
129 "convertible to the value_type.");
130
131 private:
135 ROL::Ptr<VectorType> vector_ptr;
136
137 public:
141 VectorAdaptor(const ROL::Ptr<VectorType> &vector_ptr);
142
146 ROL::Ptr<VectorType>
148
152 ROL::Ptr<const VectorType>
153 getVector() const;
154
158 int
159 dimension() const;
160
169 void
170 set(const ROL::Vector<value_type> &rol_vector);
171
175 void
176 plus(const ROL::Vector<value_type> &rol_vector);
177
182 void
183 axpy(const value_type alpha, const ROL::Vector<value_type> &rol_vector);
184
188 void
189 scale(const value_type alpha);
190
195 dot(const ROL::Vector<value_type> &rol_vector) const;
196
207 norm() const;
208
212 ROL::Ptr<ROL::Vector<value_type>>
213 clone() const;
214
219 ROL::Ptr<ROL::Vector<value_type>>
220 basis(const int i) const;
221
225 void
226 applyUnary(const ROL::Elementwise::UnaryFunction<value_type> &f);
227
232 void
233 applyBinary(const ROL::Elementwise::BinaryFunction<value_type> &f,
234 const ROL::Vector<value_type> &rol_vector);
235
241 reduce(const ROL::Elementwise::ReductionOp<value_type> &r) const;
242
246 void
247 print(std::ostream &outStream) const;
248 };
249
250
251 /*------------------------------member definitions--------------------------*/
252# ifndef DOXYGEN
253
254
255 template <typename VectorType>
257 const ROL::Ptr<VectorType> &vector_ptr)
258 : vector_ptr(vector_ptr)
259 {}
260
261
262
263 template <typename VectorType>
264 ROL::Ptr<VectorType>
266 {
267 return vector_ptr;
268 }
269
270
271
272 template <typename VectorType>
273 ROL::Ptr<const VectorType>
275 {
276 return vector_ptr;
277 }
278
279
280
281 template <typename VectorType>
282 void
283 VectorAdaptor<VectorType>::set(const ROL::Vector<value_type> &rol_vector)
284 {
285 const VectorAdaptor &vector_adaptor =
286 dynamic_cast<const VectorAdaptor &>(rol_vector);
287
288 (*vector_ptr) = *(vector_adaptor.getVector());
289 }
290
291
292
293 template <typename VectorType>
294 void
295 VectorAdaptor<VectorType>::plus(const ROL::Vector<value_type> &rol_vector)
296 {
297 Assert(this->dimension() == rol_vector.dimension(),
298 ExcDimensionMismatch(this->dimension(), rol_vector.dimension()));
299
300 const VectorAdaptor &vector_adaptor =
301 dynamic_cast<const VectorAdaptor &>(rol_vector);
302
303 *vector_ptr += *(vector_adaptor.getVector());
304 }
305
306
307
308 template <typename VectorType>
309 void
310 VectorAdaptor<VectorType>::axpy(const value_type alpha,
311 const ROL::Vector<value_type> &rol_vector)
312 {
313 Assert(this->dimension() == rol_vector.dimension(),
314 ExcDimensionMismatch(this->dimension(), rol_vector.dimension()));
315
316 const VectorAdaptor &vector_adaptor =
317 dynamic_cast<const VectorAdaptor &>(rol_vector);
318
319 vector_ptr->add(alpha, *(vector_adaptor.getVector()));
320 }
321
322
323
324 template <typename VectorType>
325 int
327 {
328 Assert(vector_ptr->size() < std::numeric_limits<int>::max(),
329 ExcMessage("The size of the vector being used is greater than "
330 "largest value of type int."));
331 return static_cast<int>(vector_ptr->size());
332 }
333
334
335
336 template <typename VectorType>
337 void
338 VectorAdaptor<VectorType>::scale(const value_type alpha)
339 {
340 (*vector_ptr) *= alpha;
341 }
342
343
344
345 template <typename VectorType>
346 typename VectorType::value_type
348 const ROL::Vector<value_type> &rol_vector) const
349 {
350 Assert(this->dimension() == rol_vector.dimension(),
351 ExcDimensionMismatch(this->dimension(), rol_vector.dimension()));
352
353 const VectorAdaptor &vector_adaptor =
354 dynamic_cast<const VectorAdaptor &>(rol_vector);
355
356 return (*vector_ptr) * (*vector_adaptor.getVector());
357 }
358
359
360
361 template <typename VectorType>
362 typename VectorType::value_type
364 {
365 return vector_ptr->l2_norm();
366 }
367
368
369
370 template <typename VectorType>
371 ROL::Ptr<ROL::Vector<typename VectorType::value_type>>
373 {
374 ROL::Ptr<VectorType> vec_ptr = ROL::makePtr<VectorType>(*vector_ptr);
375
376 return ROL::makePtr<VectorAdaptor>(vec_ptr);
377 }
378
379
380
381 template <typename VectorType>
382 ROL::Ptr<ROL::Vector<typename VectorType::value_type>>
383 VectorAdaptor<VectorType>::basis(const int i) const
384 {
385 ROL::Ptr<VectorType> vec_ptr = ROL::makePtr<VectorType>();
386
387 // Zero all the entries in dealii vector.
388 vec_ptr->reinit(*vector_ptr, false);
389
390 if (vector_ptr->locally_owned_elements().is_element(i))
391 vec_ptr->operator[](i) = 1.;
392
393 if (vec_ptr->has_ghost_elements())
394 {
395 vec_ptr->update_ghost_values();
396 }
397 else
398 {
399 vec_ptr->compress(VectorOperation::insert);
400 }
401
402 return ROL::makePtr<VectorAdaptor>(vec_ptr);
403 }
404
405
406
407 template <typename VectorType>
408 void
410 const ROL::Elementwise::UnaryFunction<value_type> &f)
411 {
412 const typename VectorType::iterator vend = vector_ptr->end();
413
414 for (typename VectorType::iterator iterator = vector_ptr->begin();
415 iterator != vend;
416 iterator++)
417 *iterator = f.apply(*iterator);
418
419 if (vector_ptr->has_ghost_elements())
420 {
421 vector_ptr->update_ghost_values();
422 }
423 else
424 {
425 vector_ptr->compress(VectorOperation::insert);
426 }
427 }
428
429
430
431 template <typename VectorType>
432 void
434 const ROL::Elementwise::BinaryFunction<value_type> &f,
435 const ROL::Vector<value_type> &rol_vector)
436 {
437 Assert(this->dimension() == rol_vector.dimension(),
438 ExcDimensionMismatch(this->dimension(), rol_vector.dimension()));
439
440 const VectorAdaptor &vector_adaptor =
441 dynamic_cast<const VectorAdaptor &>(rol_vector);
442
443 const VectorType &given_rol_vector = *(vector_adaptor.getVector());
444
445 const typename VectorType::iterator vend = vector_ptr->end();
446 const typename VectorType::const_iterator rolend = given_rol_vector.end();
447
448 typename VectorType::const_iterator r_iterator = given_rol_vector.begin();
449 for (typename VectorType::iterator l_iterator = vector_ptr->begin();
450 l_iterator != vend && r_iterator != rolend;
451 l_iterator++, r_iterator++)
452 *l_iterator = f.apply(*l_iterator, *r_iterator);
453
454 if (vector_ptr->has_ghost_elements())
455 {
456 vector_ptr->update_ghost_values();
457 }
458 else
459 {
460 vector_ptr->compress(VectorOperation::insert);
461 }
462 }
463
464
465
466 template <typename VectorType>
467 typename VectorType::value_type
469 const ROL::Elementwise::ReductionOp<value_type> &r) const
470 {
471 typename VectorType::value_type result = r.initialValue();
472
473 const typename VectorType::iterator vend = vector_ptr->end();
474
475 for (typename VectorType::iterator iterator = vector_ptr->begin();
476 iterator != vend;
477 iterator++)
478 r.reduce(*iterator, result);
479 // Parallel reduction among processes is handled internally.
480
481 return result;
482 }
483
484
485
486 template <typename VectorType>
487 void
488 VectorAdaptor<VectorType>::print(std::ostream &outStream) const
489 {
490 vector_ptr->print(outStream);
491 }
492
493
494# endif // DOXYGEN
495
496
497} // namespace Rol
498
499
501
502
503#endif // DEAL_II_TRILINOS_WITH_ROL
504
505#endif // dealii_optimization_rol_vector_adaptor_h
void applyBinary(const ROL::Elementwise::BinaryFunction< value_type > &f, const ROL::Vector< value_type > &rol_vector)
void scale(const value_type alpha)
value_type dot(const ROL::Vector< value_type > &rol_vector) const
ROL::Ptr< ROL::Vector< value_type > > basis(const int i) const
void applyUnary(const ROL::Elementwise::UnaryFunction< value_type > &f)
int dimension() const
typename VectorType::value_type value_type
typename VectorType::real_type real_type
void print(std::ostream &outStream) const
ROL::Ptr< ROL::Vector< value_type > > clone() const
typename VectorType::size_type size_type
ROL::Ptr< VectorType > getVector()
VectorAdaptor(const ROL::Ptr< VectorType > &vector_ptr)
void set(const ROL::Vector< value_type > &rol_vector)
void plus(const ROL::Vector< value_type > &rol_vector)
void axpy(const value_type alpha, const ROL::Vector< value_type > &rol_vector)
ROL::Ptr< const VectorType > getVector() const
value_type reduce(const ROL::Elementwise::ReductionOp< value_type > &r) const
value_type norm() const
ROL::Ptr< VectorType > vector_ptr
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:40
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:41
#define Assert(cond, exc)
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
static ::ExceptionBase & ExcMessage(std::string arg1)
Tpetra::Vector< Number, LO, GO, NodeType< MemorySpace > > VectorType