Reference documentation for deal.II version Git 409ee4b167 2020-08-14 09:46:12 -0400
\(\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\}}\)
vector_adaptor.h
Go to the documentation of this file.
1 //-----------------------------------------------------------
2 //
3 // Copyright (C) 2017 - 2020 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 //---------------------------------------------------------------
15 
16 #ifndef dealii_optimization_rol_vector_adaptor_h
17 #define dealii_optimization_rol_vector_adaptor_h
18 
19 #include <deal.II/base/config.h>
20 
21 #ifdef DEAL_II_TRILINOS_WITH_ROL
22 # include <deal.II/base/exceptions.h>
23 
24 # include <deal.II/lac/vector.h>
25 
26 # include <ROL_Vector.hpp>
27 
28 # include <type_traits>
29 
30 
32 
38 namespace Rol
39 {
109  template <typename VectorType>
110  class VectorAdaptor : public ROL::Vector<typename VectorType::value_type>
111  {
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<real_type, value_type>::value,
128  "The real_type of the current VectorType is not "
129  "convertible to the value_type.");
130 
131  private:
136  Teuchos::RCP<VectorType> vector_ptr;
137 
138  public:
142  VectorAdaptor(const Teuchos::RCP<VectorType> &vector_ptr);
143 
148  Teuchos::RCP<VectorType>
149  getVector();
150 
154  Teuchos::RCP<const VectorType>
155  getVector() const;
156 
160  int
161  dimension() const;
162 
171  void
172  set(const ROL::Vector<value_type> &rol_vector);
173 
177  void
178  plus(const ROL::Vector<value_type> &rol_vector);
179 
184  void
185  axpy(const value_type alpha, const ROL::Vector<value_type> &rol_vector);
186 
190  void
191  scale(const value_type alpha);
192 
196  value_type
197  dot(const ROL::Vector<value_type> &rol_vector) const;
198 
208  value_type
209  norm() const;
210 
214  Teuchos::RCP<ROL::Vector<value_type>>
215  clone() const;
216 
222  Teuchos::RCP<ROL::Vector<value_type>>
223  basis(const int i) const;
224 
228  void
229  applyUnary(const ROL::Elementwise::UnaryFunction<value_type> &f);
230 
235  void
236  applyBinary(const ROL::Elementwise::BinaryFunction<value_type> &f,
237  const ROL::Vector<value_type> & rol_vector);
238 
243  value_type
244  reduce(const ROL::Elementwise::ReductionOp<value_type> &r) const;
245 
249  void
250  print(std::ostream &outStream) const;
251  };
252 
253 
254  /*------------------------------member definitions--------------------------*/
255 # ifndef DOXYGEN
256 
257 
258  template <typename VectorType>
260  const Teuchos::RCP<VectorType> &vector_ptr)
261  : vector_ptr(vector_ptr)
262  {}
263 
264 
265 
266  template <typename VectorType>
267  Teuchos::RCP<VectorType>
269  {
270  return vector_ptr;
271  }
272 
273 
274 
275  template <typename VectorType>
276  Teuchos::RCP<const VectorType>
278  {
279  return vector_ptr;
280  }
281 
282 
283 
284  template <typename VectorType>
285  void
286  VectorAdaptor<VectorType>::set(const ROL::Vector<value_type> &rol_vector)
287  {
288  const VectorAdaptor &vector_adaptor =
289  Teuchos::dyn_cast<const VectorAdaptor>(rol_vector);
290 
291  (*vector_ptr) = *(vector_adaptor.getVector());
292  }
293 
294 
295 
296  template <typename VectorType>
297  void
298  VectorAdaptor<VectorType>::plus(const ROL::Vector<value_type> &rol_vector)
299  {
300  Assert(this->dimension() == rol_vector.dimension(),
301  ExcDimensionMismatch(this->dimension(), rol_vector.dimension()));
302 
303  const VectorAdaptor &vector_adaptor =
304  Teuchos::dyn_cast<const VectorAdaptor>(rol_vector);
305 
306  *vector_ptr += *(vector_adaptor.getVector());
307  }
308 
309 
310 
311  template <typename VectorType>
312  void
314  const ROL::Vector<value_type> &rol_vector)
315  {
316  Assert(this->dimension() == rol_vector.dimension(),
317  ExcDimensionMismatch(this->dimension(), rol_vector.dimension()));
318 
319  const VectorAdaptor &vector_adaptor =
320  Teuchos::dyn_cast<const VectorAdaptor>(rol_vector);
321 
322  vector_ptr->add(alpha, *(vector_adaptor.getVector()));
323  }
324 
325 
326 
327  template <typename VectorType>
328  int
330  {
331  Assert(vector_ptr->size() < std::numeric_limits<int>::max(),
332  ExcMessage("The size of the vector being used is greater than "
333  "largest value of type int."));
334  return static_cast<int>(vector_ptr->size());
335  }
336 
337 
338 
339  template <typename VectorType>
340  void
342  {
343  (*vector_ptr) *= alpha;
344  }
345 
346 
347 
348  template <typename VectorType>
349  typename VectorType::value_type
351  const ROL::Vector<value_type> &rol_vector) const
352  {
353  Assert(this->dimension() == rol_vector.dimension(),
354  ExcDimensionMismatch(this->dimension(), rol_vector.dimension()));
355 
356  const VectorAdaptor &vector_adaptor =
357  Teuchos::dyn_cast<const VectorAdaptor>(rol_vector);
358 
359  return (*vector_ptr) * (*vector_adaptor.getVector());
360  }
361 
362 
363 
364  template <typename VectorType>
365  typename VectorType::value_type
367  {
368  return vector_ptr->l2_norm();
369  }
370 
371 
372 
373  template <typename VectorType>
374  Teuchos::RCP<ROL::Vector<typename VectorType::value_type>>
376  {
377  Teuchos::RCP<VectorType> vec_ptr = Teuchos::rcp(new VectorType);
378  (*vec_ptr) = (*vector_ptr);
379 
380  return Teuchos::rcp(new VectorAdaptor(vec_ptr));
381  }
382 
383 
384 
385  template <typename VectorType>
386  Teuchos::RCP<ROL::Vector<typename VectorType::value_type>>
387  VectorAdaptor<VectorType>::basis(const int i) const
388  {
389  Teuchos::RCP<VectorType> vec_ptr = Teuchos::rcp(new VectorType);
390 
391  // Zero all the entries in dealii vector.
392  vec_ptr->reinit(*vector_ptr, false);
393 
394  if (vector_ptr->locally_owned_elements().is_element(i))
395  vec_ptr->operator[](i) = 1.;
396 
397  if (vec_ptr->has_ghost_elements())
398  {
399  vec_ptr->update_ghost_values();
400  }
401  else
402  {
403  vec_ptr->compress(VectorOperation::insert);
404  }
405 
406  Teuchos::RCP<VectorAdaptor> e = Teuchos::rcp(new VectorAdaptor(vec_ptr));
407 
408  return e;
409  }
410 
411 
412 
413  template <typename VectorType>
414  void
416  const ROL::Elementwise::UnaryFunction<value_type> &f)
417  {
418  const typename VectorType::iterator vend = vector_ptr->end();
419 
420  for (typename VectorType::iterator iterator = vector_ptr->begin();
421  iterator != vend;
422  iterator++)
423  *iterator = f.apply(*iterator);
424 
425  if (vector_ptr->has_ghost_elements())
426  {
427  vector_ptr->update_ghost_values();
428  }
429  else
430  {
431  vector_ptr->compress(VectorOperation::insert);
432  }
433  }
434 
435 
436 
437  template <typename VectorType>
438  void
440  const ROL::Elementwise::BinaryFunction<value_type> &f,
441  const ROL::Vector<value_type> & rol_vector)
442  {
443  Assert(this->dimension() == rol_vector.dimension(),
444  ExcDimensionMismatch(this->dimension(), rol_vector.dimension()));
445 
446  const VectorAdaptor &vector_adaptor =
447  Teuchos::dyn_cast<const VectorAdaptor>(rol_vector);
448 
449  const VectorType &given_rol_vector = *(vector_adaptor.getVector());
450 
451  const typename VectorType::iterator vend = vector_ptr->end();
452  const typename VectorType::const_iterator rolend = given_rol_vector.end();
453 
454  typename VectorType::const_iterator r_iterator = given_rol_vector.begin();
455  for (typename VectorType::iterator l_iterator = vector_ptr->begin();
456  l_iterator != vend && r_iterator != rolend;
457  l_iterator++, r_iterator++)
458  *l_iterator = f.apply(*l_iterator, *r_iterator);
459 
460  if (vector_ptr->has_ghost_elements())
461  {
462  vector_ptr->update_ghost_values();
463  }
464  else
465  {
466  vector_ptr->compress(VectorOperation::insert);
467  }
468  }
469 
470 
471 
472  template <typename VectorType>
473  typename VectorType::value_type
475  const ROL::Elementwise::ReductionOp<value_type> &r) const
476  {
477  typename VectorType::value_type result = r.initialValue();
478 
479  const typename VectorType::iterator vend = vector_ptr->end();
480 
481  for (typename VectorType::iterator iterator = vector_ptr->begin();
482  iterator != vend;
483  iterator++)
484  r.reduce(*iterator, result);
485  // Parallel reduction among processes is handled internally.
486 
487  return result;
488  }
489 
490 
491 
492  template <typename VectorType>
493  void
494  VectorAdaptor<VectorType>::print(std::ostream &outStream) const
495  {
496  vector_ptr->print(outStream);
497  }
498 
499 
500 # endif // DOXYGEN
501 
502 
503 } // namespace Rol
504 
505 
507 
508 
509 #endif // DEAL_II_TRILINOS_WITH_ROL
510 
511 #endif // dealii_optimization_rol_vector_adaptor_h
types::global_dof_index size_type
Definition: cuda_kernels.h:45
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
void applyBinary(const ROL::Elementwise::BinaryFunction< value_type > &f, const ROL::Vector< value_type > &rol_vector)
VectorAdaptor(const Teuchos::RCP< VectorType > &vector_ptr)
Teuchos::RCP< ROL::Vector< value_type > > clone() const
Teuchos::RCP< VectorType > getVector()
void applyUnary(const ROL::Elementwise::UnaryFunction< value_type > &f)
value_type norm() const
Teuchos::RCP< VectorType > vector_ptr
typename VectorType::value_type value_type
static ::ExceptionBase & ExcMessage(std::string arg1)
void plus(const ROL::Vector< value_type > &rol_vector)
#define Assert(cond, exc)
Definition: exceptions.h:1411
value_type dot(const ROL::Vector< value_type > &rol_vector) const
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
void print(std::ostream &outStream) const
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:363
int dimension() const
value_type reduce(const ROL::Elementwise::ReductionOp< value_type > &r) const
Teuchos::RCP< ROL::Vector< value_type > > basis(const int i) const
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:362
typename VectorType::real_type real_type
typename VectorType::size_type size_type
void axpy(const value_type alpha, const ROL::Vector< value_type > &rol_vector)
void set(const ROL::Vector< value_type > &rol_vector)
T max(const T &t, const MPI_Comm &mpi_communicator)
void scale(const value_type alpha)