Since version 9.0, deal.II requires a compiler that supports at least C++11. As part of this, many places in the internal implementation of deal.II are now using features that were only introduced in C++11. That said, deal.II also has functions and classes that make using it with C++11 features easier. More...

Classes
class	IteratorRange< Iterator >

Functions
template<typename FunctionObjectType >
auto	Threads::new_thread (FunctionObjectType function_object) -> Thread< decltype(function_object())>

template<typename FunctionObjectType >
auto	Threads::new_task (FunctionObjectType function_object) -> Task< decltype(function_object())>

template<typename BaseIterator , typename Predicate >
IteratorRange< FilteredIterator< BaseIterator > >	filter_iterators (IteratorRange< BaseIterator > i, const Predicate &p)

template<typename BaseIterator , typename Predicate , typename... Targs>
IteratorRange< typename internal::FilteredIteratorImplementation::NestFilteredIterators< BaseIterator, std::tuple< Predicate, Targs... > >::type >	filter_iterators (IteratorRange< BaseIterator > i, const Predicate &p, const Targs... args)

template<typename BaseIterator , typename Predicate >
IteratorRange< FilteredIterator< BaseIterator > >	filter_iterators (IteratorRange< BaseIterator > i, const Predicate &p)

template<typename BaseIterator , typename Predicate , typename... Targs>
IteratorRange< typename internal::FilteredIteratorImplementation::NestFilteredIterators< BaseIterator, std::tuple< Predicate, Targs... > >::type >	filter_iterators (IteratorRange< BaseIterator > i, const Predicate &p, const Targs... args)

Cell iterator functions returning ranges of iterators
IteratorRange< cell_iterator >	DoFHandler< dim, spacedim >::cell_iterators () const

IteratorRange< active_cell_iterator >	DoFHandler< dim, spacedim >::active_cell_iterators () const

IteratorRange< level_cell_iterator >	DoFHandler< dim, spacedim >::mg_cell_iterators () const

IteratorRange< cell_iterator >	DoFHandler< dim, spacedim >::cell_iterators_on_level (const unsigned int level) const

IteratorRange< active_cell_iterator >	DoFHandler< dim, spacedim >::active_cell_iterators_on_level (const unsigned int level) const

IteratorRange< level_cell_iterator >	DoFHandler< dim, spacedim >::mg_cell_iterators_on_level (const unsigned int level) const

Cell iterator functions returning ranges of iterators
IteratorRange< cell_iterator >	Triangulation< dim, spacedim >::cell_iterators () const

IteratorRange< active_cell_iterator >	Triangulation< dim, spacedim >::active_cell_iterators () const

IteratorRange< cell_iterator >	Triangulation< dim, spacedim >::cell_iterators_on_level (const unsigned int level) const

IteratorRange< active_cell_iterator >	Triangulation< dim, spacedim >::active_cell_iterators_on_level (const unsigned int level) const

Face iterator functions
IteratorRange< active_face_iterator >	Triangulation< dim, spacedim >::active_face_iterators () const

Cell iterator functions returning ranges of iterators
IteratorRange< cell_iterator >	hp::DoFHandler< dim, spacedim >::cell_iterators () const

IteratorRange< active_cell_iterator >	hp::DoFHandler< dim, spacedim >::active_cell_iterators () const

IteratorRange< cell_iterator >	hp::DoFHandler< dim, spacedim >::cell_iterators_on_level (const unsigned int level) const

IteratorRange< active_cell_iterator >	hp::DoFHandler< dim, spacedim >::active_cell_iterators_on_level (const unsigned int level) const

Detailed Description

Since version 9.0, deal.II requires a compiler that supports at least C++11. As part of this, many places in the internal implementation of deal.II are now using features that were only introduced in C++11. That said, deal.II also has functions and classes that make using it with C++11 features easier.

One example is support for C++11 range-based for loops. deal.II-based codes often have many loops of the kind

Triangulation<dim> triangulation;
...
typename Triangulation<dim>::active_cell_iterator
  cell = triangulation.begin_active(),
  endc = triangulation.end();
for (; cell!=endc; ++cell)
  cell->set_refine_flag();

Using C++11's range-based for loops, you can now write this as follows:

Triangulation<dim> triangulation;
...
for (auto &cell : triangulation.active_cell_iterators())
  cell->set_refine_flag();

This relies on functions such as Triangulation::active_cell_iterators(), and equivalents in the DoF handler classes, DoFHandler::active_cell_iterators(), hp::DoFHandler::active_cell_iterators(). There are variants of these functions that provide iterator ranges for all cells (not just the active ones) and for cells on individual levels.

There are numerous other functions in the library that allow for the idiomatic use of range-based for loops. Examples are GeometryInfo::face_indices(), GeometryInfo::vertex_indices(), FEValuesBase::quadrature_point_indices(), among many others.

C++11 also introduces the concept of constexpr variables and function. The variables defined as constexpr are constant values that are computed during the compilation of the program and therefore have zero runtime cost associated with their initialization. Additionally, constexpr constants have properly defined lifetimes which prevent the so-called "static initialization order fiasco" completely. Functions can be marked as constexpr, indicating that they can produce compile-time constant return values if their input arguments are constant expressions. Additionally, classes with at least one constexpr constructor can be initialized as constexpr.

As an example, since the constructor Tensor::Tensor(const array_type &) is constexpr, we can initialize a tensor with an array during compile time as:

constexpr double[2][2] entries = {{1., 0.}, {0., 1.}};

constexpr Tensor<2, 2> A(entries);

Here, the contents of A are not stored on the stack. Rather, they are initialized during compile time and inserted into the .data portion of the executable program. The program can use these values at runtime without spending time for initialization. Initializing tensors can be simplified in one line.

constexpr Tensor<2, 2> A({{1., 0.}, {0., 1.}});

Some functions such as determinant() are specified as constexpr but they require a compiler with C++14 capability. As such, this function is internally declared as:

template <int dim, typename Number>

DEAL_II_CONSTEXPR Number determinant(const Tensor<2, dim, Number> &t);

The macro DEAL_II_CONSTEXPR simplifies to constexpr if a C++14-capable compiler is available. Otherwise, for old compilers, it ignores DEAL_II_CONSTEXPR altogether. Therefore, with newer compilers, the user can write

constexpr double det_A = determinant(A);

assuming A is declared with the constexpr specifier. This example shows the performance gains of using constexpr because here we performed an operation with \(O(\text{dim}^3)\) complexity during compile time, avoiding any runtime cost.

Function Documentation

◆ new_thread()

template<typename FunctionObjectType >

auto Threads::new_thread ( FunctionObjectType function_object ) -> Thread<decltype(function_object())>

inline

Overload of the new_thread() function for objects that can be called like a function object without arguments. In particular, this function allows calling Threads::new_thread() with either objects that result from using std::bind, or using lambda functions. For example, this function is called when writing code such as

Threads::Thread<int>
  thread = Threads::new_thread ( [] () {
                                         do_this();
                                         then_do_that();
                                         return 42;
                                       });

Here, we run the sequence of functions do_this() and then_do_that() on a separate thread, by making the lambda function declared here the function to execute on the thread. The lambda function then returns 42 (which is a bit pointless here, but it could of course be some computed number), and this is going to be the returned value you can later retrieve via thread.return_value() once the thread (i.e., the body of the lambda function) has completed.

Note: Every lambda function (or whatever else it is you pass to the new_thread() function here, for example the result of a std::bind() expression) has a return type and consequently returns an object of this type. This type can be inferred using the C++11 decltype statement used in the declaration of this function, and it is then used as the template argument of the Threads::Thread object returned by the current function. In the example above, because the lambda function returns 42 (which in C++ has data type int), the inferred type is int and the task object will have type Task<int>. In other words, it is not necessary to explicitly specify in user code what that return type of the lambda or std::bind expression will be, though it is possible to explicitly do so by (entirely equivalently) writing
Threads::Thread<int>

thread = Threads::new_thread ( [] () -> int {

do_this();

then_do_that();

return 42;

});; In practice, the lambda functions you will pass to new_thread() will of course typically be more complicated. In particular, they will likely capture variables from the surrounding context and use them within the lambda. See https://en.wikipedia.org/wiki/Anonymous_function#C.2B.2B_.28since_C.2B.2B11.29 for more on how lambda functions work.; If you pass a lambda function as an argument to the current function that captures a variable by reference, or if you use a std::bind that binds a function argument to a reference variable using std::ref() or std::cref(), then obviously you can only do this if the variables you reference or capture have a lifetime that extends at least until the time where the thread finishes.

Definition at line 1083 of file thread_management.h.

◆ new_task()

template<typename FunctionObjectType >

auto Threads::new_task ( FunctionObjectType function_object ) -> Task<decltype(function_object())>

inline

Overload of the new_task function for objects that can be called like a function object without arguments. In particular, this function allows calling Threads::new_task() with either objects that result from using std::bind, or using lambda functions. For example, this function is called when writing code such as

Threads::Task<int>
  task = Threads::new_task ( [] () {
                                     do_this();
                                     then_do_that();
                                     return 42;
                                   });

Here, we schedule the call to the sequence of functions do_this() and then_do_that() on a separate task, by making the lambda function declared here the function to execute on the task. The lambda function then returns 42 (which is a bit pointless here, but it could of course be some computed number), and this is going to be the returned value you can later retrieve via task.return_value() once the task (i.e., the body of the lambda function) has completed.

Note: Every lambda function (or whatever else it is you pass to the new_task() function here, for example the result of a std::bind() expression) has a return type and consequently returns an object of this type. This type can be inferred using the C++11 decltype statement used in the declaration of this function, and it is then used as the template argument of the Threads::Task object returned by the current function. In the example above, because the lambda function returns 42 (which in C++ has data type int), the inferred type is int and the task object will have type Task<int>. In other words, it is not necessary to explicitly specify in user code what that return type of the lambda or std::bind expression will be, though it is possible to explicitly do so by (entirely equivalently) writing
Threads::Task<int>

task = Threads::new_task ( [] () -> int {

do_this();

then_do_that();

return 42;

});; In practice, the lambda functions you will pass to new_task() will of course typically be more complicated. In particular, they will likely capture variables from the surrounding context and use them within the lambda. See https://en.wikipedia.org/wiki/Anonymous_function#C.2B.2B_.28since_C.2B.2B11.29 for more on how lambda functions work.; If you pass a lambda function as an argument to the current function that captures a variable by reference, or if you use a std::bind that binds a function argument to a reference variable using std::ref() or std::cref(), then obviously you can only do this if the variables you reference or capture have a lifetime that extends at least until the time where the task finishes.

Definition at line 1720 of file thread_management.h.

◆ cell_iterators() [1/3]

template<int dim, int spacedim>

IteratorRange< typename DoFHandler< dim, spacedim >::cell_iterator > DoFHandler< dim, spacedim >::cell_iterators

Return an iterator range that contains all cells (active or not) that make up this DoFHandler. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Returns: The half open range [this->begin(), this->end())

Definition at line 1021 of file dof_handler.cc.

◆ active_cell_iterators() [1/3]

template<int dim, int spacedim>

IteratorRange< typename DoFHandler< dim, spacedim >::active_cell_iterator > DoFHandler< dim, spacedim >::active_cell_iterators

Return an iterator range that contains all active cells that make up this DoFHandler. Such a range is useful to initialize range-based for loops as supported by C++11, see also C++11 standard.

Range-based for loops are useful in that they require much less code than traditional loops (see here for a discussion of how they work). An example is that without range-based for loops, one often writes code such as the following:

DoFHandler<dim> dof_handler;
...
typename DoFHandler<dim>::active_cell_iterator
  cell = dof_handler.begin_active(),
  endc = dof_handler.end();
for (; cell!=endc; ++cell)
  {
    fe_values.reinit (cell);
    ...do the local integration on 'cell'...;
  }

Using C++11's range-based for loops, this is now entirely equivalent to the following:

DoFHandler<dim> dof_handler;
...
for (const auto &cell : dof_handler.active_cell_iterators())
  {
    fe_values.reinit (cell);
    ...do the local integration on 'cell'...;
  }

Returns: The half open range [this->begin_active(), this->end())

Definition at line 1030 of file dof_handler.cc.

◆ mg_cell_iterators()

template<int dim, int spacedim>

IteratorRange< typename DoFHandler< dim, spacedim >::level_cell_iterator > DoFHandler< dim, spacedim >::mg_cell_iterators

Return an iterator range that contains all cells (active or not) that make up this DoFHandler in their level-cell form. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Returns: The half open range [this->begin_mg(), this->end_mg())

Definition at line 1041 of file dof_handler.cc.

◆ cell_iterators_on_level() [1/3]

template<int dim, int spacedim>

IteratorRange< typename DoFHandler< dim, spacedim >::cell_iterator > DoFHandler< dim, spacedim >::cell_iterators_on_level ( const unsigned int level ) const

Return an iterator range that contains all cells (active or not) that make up the given level of this DoFHandler. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Parameters

[in] level A given level in the refinement hierarchy of this triangulation.

Returns: The half open range [this->begin(level), this->end(level))

Precondition: level must be less than this->n_levels().

Definition at line 1051 of file dof_handler.cc.

◆ active_cell_iterators_on_level() [1/3]

template<int dim, int spacedim>

IteratorRange< typename DoFHandler< dim, spacedim >::active_cell_iterator > DoFHandler< dim, spacedim >::active_cell_iterators_on_level ( const unsigned int level ) const

Return an iterator range that contains all active cells that make up the given level of this DoFHandler. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Parameters

[in] level A given level in the refinement hierarchy of this triangulation.

Returns: The half open range [this->begin_active(level), this->end(level))

Precondition: level must be less than this->n_levels().

Definition at line 1062 of file dof_handler.cc.

◆ mg_cell_iterators_on_level()

template<int dim, int spacedim>

IteratorRange< typename DoFHandler< dim, spacedim >::level_cell_iterator > DoFHandler< dim, spacedim >::mg_cell_iterators_on_level ( const unsigned int level ) const

Return an iterator range that contains all cells (active or not) that make up the given level of this DoFHandler in their level-cell form. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Parameters

[in] level A given level in the refinement hierarchy of this triangulation.

Returns: The half open range [this->begin_mg(level), this->end_mg(level))

Precondition: level must be less than this->n_levels().

Definition at line 1074 of file dof_handler.cc.

◆ filter_iterators() [1/4]

template<typename BaseIterator , typename Predicate >

IteratorRange< FilteredIterator< BaseIterator > > filter_iterators	(	IteratorRange< BaseIterator >	i,
		const Predicate &	p
	)

Filter the given range of iterators using a Predicate. This allows to replace:

DoFHandler<dim> dof_handler;
...
for (const auto &cell : dof_handler.active_cell_iterators())
  {
    if (cell->is_locally_owned())
      {
        fe_values.reinit (cell);
        ...do the local integration on 'cell'...;
      }
  }

by:

DoFHandler<dim> dof_handler;
...
const auto filtered_iterators_range =
  filter_iterators(dof_handler.active_cell_iterators(),
                   IteratorFilters::LocallyOwnedCell());
for (const auto &cell : filtered_iterators_range)
  {
    fe_values.reinit (cell);
    ...do the local integration on 'cell'...;
  }

Author: Bruno Turcksin, 2016

Definition at line 867 of file filtered_iterator.h.

◆ filter_iterators() [2/4]

template<typename BaseIterator , typename Predicate , typename... Targs>

IteratorRange< typename internal::FilteredIteratorImplementation::NestFilteredIterators< BaseIterator, std::tuple< Predicate, Targs... > >::type > filter_iterators	(	IteratorRange< BaseIterator >	i,
		const Predicate &	p,
		const Targs...	args
	)

Filter the given range of iterators through an arbitrary number of Predicates. This allows to replace:

DoFHandler<dim> dof_handler;
...
for (const auto &cell : dof_handler.active_cell_iterators())
  {
    if (cell->is_locally_owned())
      {
        if (cell->at_boundary())
          {
            fe_values.reinit (cell);
            ...do the local integration on 'cell'...;
          }
      }
  }

by:

DoFHandler<dim> dof_handler;
...
const auto filtered_iterators_range =
  filter_iterators(dof_handler.active_cell_iterators(),
                   IteratorFilters::LocallyOwnedCell(),
                   IteratorFilters::AtBoundary());
for (const auto &cell : filter_iterators_range)
  {
    fe_values.reinit (cell);
    ...do the local integration on 'cell'...;
  }

Author: Bruno Turcksin, 2016

Definition at line 918 of file filtered_iterator.h.

◆ cell_iterators() [2/3]

template<int dim, int spacedim>

IteratorRange< typename Triangulation< dim, spacedim >::cell_iterator > Triangulation< dim, spacedim >::cell_iterators

Return an iterator range that contains all cells (active or not) that make up this triangulation. Such a range is useful to initialize range- based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Returns: The half open range [this->begin(), this->end())

Definition at line 12176 of file tria.cc.

◆ active_cell_iterators() [2/3]

template<int dim, int spacedim>

IteratorRange< typename Triangulation< dim, spacedim >::active_cell_iterator > Triangulation< dim, spacedim >::active_cell_iterators

Return an iterator range that contains all active cells that make up this triangulation. Such a range is useful to initialize range-based for loops as supported by C++11, see also C++11 standard.

Range-based for loops are useful in that they require much less code than traditional loops (see here for a discussion of how they work). An example is that without range-based for loops, one often writes code such as the following (assuming for a moment that our goal is setting the user flag on every active cell):

Triangulation<dim> triangulation;
...
typename Triangulation<dim>::active_cell_iterator
  cell = triangulation.begin_active(),
  endc = triangulation.end();
for (; cell!=endc; ++cell)
  cell->set_user_flag();

Using C++11's range-based for loops, this is now entirely equivalent to the following:

Triangulation<dim> triangulation;
...
for (const auto &cell : triangulation.active_cell_iterators())
  cell->set_user_flag();

Returns: The half open range [this->begin_active(), this->end())

Definition at line 12185 of file tria.cc.

◆ cell_iterators_on_level() [2/3]

template<int dim, int spacedim>

IteratorRange< typename Triangulation< dim, spacedim >::cell_iterator > Triangulation< dim, spacedim >::cell_iterators_on_level ( const unsigned int level ) const

Return an iterator range that contains all cells (active or not) that make up the given level of this triangulation. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Parameters

[in] level A given level in the refinement hierarchy of this triangulation.

Returns: The half open range [this->begin(level), this->end(level))

Precondition: level must be less than this->n_levels().

Definition at line 12196 of file tria.cc.

◆ active_cell_iterators_on_level() [2/3]

template<int dim, int spacedim>

IteratorRange< typename Triangulation< dim, spacedim >::active_cell_iterator > Triangulation< dim, spacedim >::active_cell_iterators_on_level ( const unsigned int level ) const

Return an iterator range that contains all active cells that make up the given level of this triangulation. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Parameters

[in] level A given level in the refinement hierarchy of this triangulation.

Returns: The half open range [this->begin_active(level), this->end(level))

Precondition: level must be less than this->n_levels().

Definition at line 12207 of file tria.cc.

◆ active_face_iterators()

template<int dim, int spacedim>

IteratorRange< typename Triangulation< dim, spacedim >::active_face_iterator > Triangulation< dim, spacedim >::active_face_iterators

Return an iterator range that contains all active faces that make up this triangulation. This function is the face version of Triangulation::active_cell_iterators(), and allows one to write code like, e.g.,

Triangulation<dim> triangulation;
...
for (auto &face : triangulation.active_face_iterators())
  face->set_manifold_id(42);

Returns: The half open range [this->begin_active_face(), this->end_face())

Definition at line 12284 of file tria.cc.

◆ cell_iterators() [3/3]

template<int dim, int spacedim>

IteratorRange< typename DoFHandler< dim, spacedim >::cell_iterator > DoFHandler< dim, spacedim >::cell_iterators

Return an iterator range that contains all cells (active or not) that make up this DoFHandler. Such a range is useful to initialize range- based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Returns: The half open range [this->begin(), this->end())

Definition at line 1369 of file dof_handler.cc.

◆ active_cell_iterators() [3/3]

template<int dim, int spacedim>

IteratorRange< typename DoFHandler< dim, spacedim >::active_cell_iterator > DoFHandler< dim, spacedim >::active_cell_iterators

Return an iterator range that contains all active cells that make up this DoFHandler. Such a range is useful to initialize range-based for loops as supported by C++11, see also C++11 standard.

Range-based for loops are useful in that they require much less code than traditional loops (see here for a discussion of how they work). An example is that without range-based for loops, one often writes code such as the following:

DoFHandler<dim> dof_handler;
...
typename DoFHandler<dim>::active_cell_iterator
  cell = dof_handler.begin_active(),
  endc = dof_handler.end();
for (; cell!=endc; ++cell)
  {
    fe_values.reinit (cell);
    ...do the local integration on 'cell'...;
  }

Using C++11's range-based for loops, this is now entirely equivalent to the following:

DoFHandler<dim> dof_handler;
...
for (const auto &cell : dof_handler.active_cell_iterators())
  {
    fe_values.reinit (cell);
    ...do the local integration on 'cell'...;
  }

Returns: The half open range [this->begin_active(), this->end())

Definition at line 1379 of file dof_handler.cc.

◆ cell_iterators_on_level() [3/3]

template<int dim, int spacedim>

IteratorRange< typename DoFHandler< dim, spacedim >::cell_iterator > DoFHandler< dim, spacedim >::cell_iterators_on_level ( const unsigned int level ) const

Return an iterator range that contains all cells (active or not) that make up the given level of this DoFHandler. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Parameters

[in] level A given level in the refinement hierarchy of this triangulation.

Returns: The half open range [this->begin(level), this->end(level))

Precondition: level must be less than this->n_levels().

Definition at line 1390 of file dof_handler.cc.

◆ active_cell_iterators_on_level() [3/3]

template<int dim, int spacedim>

IteratorRange< typename DoFHandler< dim, spacedim >::active_cell_iterator > DoFHandler< dim, spacedim >::active_cell_iterators_on_level ( const unsigned int level ) const

Return an iterator range that contains all active cells that make up the given level of this DoFHandler. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Parameters

[in] level A given level in the refinement hierarchy of this triangulation.

Returns: The half open range [this->begin_active(level), this->end(level))

Precondition: level must be less than this->n_levels().

Definition at line 1401 of file dof_handler.cc.

◆ filter_iterators() [3/4]

template<typename BaseIterator , typename Predicate >

IteratorRange< FilteredIterator< BaseIterator > > filter_iterators	(	IteratorRange< BaseIterator >	i,
		const Predicate &	p
	)

DoFHandler<dim> dof_handler;
...
for (const auto &cell : dof_handler.active_cell_iterators())
  {
    if (cell->is_locally_owned())
      {
        fe_values.reinit (cell);
        ...do the local integration on 'cell'...;
      }
  }

by:

DoFHandler<dim> dof_handler;
...
const auto filtered_iterators_range =
  filter_iterators(dof_handler.active_cell_iterators(),
                   IteratorFilters::LocallyOwnedCell());
for (const auto &cell : filtered_iterators_range)
  {
    fe_values.reinit (cell);
    ...do the local integration on 'cell'...;
  }

Author: Bruno Turcksin, 2016

Definition at line 867 of file filtered_iterator.h.

◆ filter_iterators() [4/4]

template<typename BaseIterator , typename Predicate , typename... Targs>

IteratorRange< typename internal::FilteredIteratorImplementation::NestFilteredIterators< BaseIterator, std::tuple< Predicate, Targs... > >::type > filter_iterators	(	IteratorRange< BaseIterator >	i,
		const Predicate &	p,
		const Targs...	args
	)

DoFHandler<dim> dof_handler;
...
for (const auto &cell : dof_handler.active_cell_iterators())
  {
    if (cell->is_locally_owned())
      {
        if (cell->at_boundary())
          {
            fe_values.reinit (cell);
            ...do the local integration on 'cell'...;
          }
      }
  }

by:

DoFHandler<dim> dof_handler;
...
const auto filtered_iterators_range =
  filter_iterators(dof_handler.active_cell_iterators(),
                   IteratorFilters::LocallyOwnedCell(),
                   IteratorFilters::AtBoundary());
for (const auto &cell : filter_iterators_range)
  {
    fe_values.reinit (cell);
    ...do the local integration on 'cell'...;
  }

Author: Bruno Turcksin, 2016

Definition at line 918 of file filtered_iterator.h.

Classes

Functions

Cell iterator functions returning ranges of iterators

Cell iterator functions returning ranges of iterators

Face iterator functions

Cell iterator functions returning ranges of iterators

Detailed Description

Function Documentation

◆ new_thread()

◆ new_task()

◆ cell_iterators() [1/3]

◆ active_cell_iterators() [1/3]

◆ mg_cell_iterators()

◆ cell_iterators_on_level() [1/3]

◆ active_cell_iterators_on_level() [1/3]

◆ mg_cell_iterators_on_level()

◆ filter_iterators() [1/4]

◆ filter_iterators() [2/4]

◆ cell_iterators() [2/3]

◆ active_cell_iterators() [2/3]

◆ cell_iterators_on_level() [2/3]

◆ active_cell_iterators_on_level() [2/3]

◆ active_face_iterators()

◆ cell_iterators() [3/3]

◆ active_cell_iterators() [3/3]

◆ cell_iterators_on_level() [3/3]

◆ active_cell_iterators_on_level() [3/3]

◆ filter_iterators() [3/4]

◆ filter_iterators() [4/4]