Merge pull request #11161 from marcfehling/hp-refinement

Functions of hp::Refinement now only available for DoFHandler in hp mode.

Merge pull request #10899 from drwells/gridin-exodusii

Support ExodusII with GridIn

Merge pull request #11162 from peterrum/step67-skew-ref

Add reference to skew-symmetric implementation in step-67

Merge pull request #11156 from peterrum/reset_ghost_values_impl

Improve VectorDataExchange::Full::reset_ghost_values

Merge pull request #11154 from peterrum/compute_shared_memory_contiguous_indices_fix

Fix compute_shared_memory_contiguous_indices

Merge pull request #11157 from peterrum/fe_face_evaluation_process_and_io_comp_fix

Fix fe_face_evaluation_process_and_io for multiple components

Merge pull request #11152 from lethe-cfd/update_ghost_particles_part_2

Finish mechanism for the update of ghost particles

Merge pull request #11133 from marcfehling/slim-dofhandler-init

Rework DoFHandler connections to underlying Triangulation.

Add reference to skew-symmetric implementation in step-67

Rework DoFHandler connections to underlying Triangulation.

Introduction of ghost particles cache and new version to send
information on ghost partilces without rebuilding them

Added a test with asymmetric ghosts because there was an error in the
previous implementation and this test enabled me to find it

Added changelog

Implement ExodusII in GridIn.

The tests were all generated by hand. For future reference I included the code here.

Here is the basic 2D test (five quadrilaterals):

#include <exodusII.h>

#include <algorithm>
#include <cassert>
#include <cstring>

// Create a disk mesh with five quadrilaterals.
//
//  ____________________________
// |\                          /|
// | \                        / |
// |  \           3          /  |
// |   \                    /   |
// |    \                  /    |
// |     \                /     |
// |      \______________/      |
// |      |              |      |
// |      |              |      |
// |      |              |      |
// |   4  |      5       |   2  |
// |      |              |      |
// |      |______________|      |
// |      /              \      |
// |     /                \     |
// |    /                  \    |
// |   /                    \   |
// |  /          1           \  |
// | /                        \ |
// |/                          \|
// -----------------------------
//
// element 1 has external side sets 0, 1
// element 2 has external side sets 0, 1, 10
// element 3 has no external side sets
// element 4 has no external side set 0
//
// The inner element is in block 10 - the rest are in block 1.
int main()
{
    const int n_elems = 5;
    const int n_nodes = 8;
    int elements_1[n_elems - 1][4] = {
    {1, 2, 3, 4},
    {3, 2, 8, 7},
    {5, 7, 8, 6},
    {1, 4, 5, 6}};
    int elements_10[1][4] = {{4, 3, 7, 5}};

    double xs[n_nodes] = {0, 7, 5, 2, 2, 0, 5, 7};
    double ys[n_nodes] = {0, 0, 2, 2, 5, 7, 5, 7};

    int sizeof_data = sizeof(double);
    int sizeof_geom = sizeof(double);
    const int exid = ex_create("five.e", EX_CLOBBER, &sizeof_data, &sizeof_geom);

    const int dim = 2;
    const int n_blocks = 2;
    const int n_node_sets = 0;
    const int n_side_sets = 3;
    int ierr = ex_put_init(exid, "mytitle", dim, n_nodes, n_elems, n_blocks,
                           n_node_sets, n_side_sets);
    assert(ierr == 0);

    // nodes:
    ierr = ex_put_coord(exid, xs, ys, nullptr);
    assert(ierr == 0);

    // element blocks:
    ierr = ex_put_elem_block(exid, 1, "quad", 4, 4, 0);
    assert(ierr == 0);
    ierr = ex_put_elem_block(exid, 10, "quad", 1, 4, 0);
    assert(ierr == 0);

    ierr = ex_put_elem_conn(exid, 10, elements_10);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 1, elements_1);
    assert(ierr == 0);

    // side sets:
    ierr = ex_put_side_set_param(exid, 0, 3, 0);
    assert(ierr == 0);
    int sideset_0_elems[] = {1, 2, 4};
    int sideset_0_sides[] = {1, 2, 4};
    ierr = ex_put_side_set(exid, 0, sideset_0_elems, sideset_0_sides);
    assert(ierr == 0);

    ierr = ex_put_side_set_param(exid, 1, 2, 0);
    assert(ierr == 0);
    int sideset_1_elems[] = {1, 2};
    int sideset_1_sides[] = {1, 2};
    ierr = ex_put_side_set(exid, 1, sideset_1_elems, sideset_1_sides);
    assert(ierr == 0);

    ierr = ex_put_side_set_param(exid, 10, 1, 0);
    assert(ierr == 0);
    int sideset_10_elems[] = {2};
    int sideset_10_sides[] = {2};
    ierr = ex_put_side_set(exid, 10, sideset_10_elems, sideset_10_sides);
    assert(ierr == 0);

    ierr = ex_close(exid);
    assert(ierr == 0);
}

A 3D mixed mesh:

#include <exodusII.h>

#include <algorithm>
#include <cassert>
#include <cstring>

int main()
{
    const int n_elems = 4;
    const int n_nodes = 13;
    int elements_1[1][8] = {{1, 2, 3, 4, 5, 6, 7, 8}};
    int elements_2[1][5] = {{5, 6, 7, 8, 9}};
    int elements_3[1][4] = {{6, 10, 7, 9}};
    int elements_4[1][6] = {{10, 6, 7, 13, 11, 12}};

    double xs[n_nodes] = {0, 3, 3, 0, 0, 3, 3, 0, 1, 3, 8, 8, 8};
    double ys[n_nodes] = {0, 0, 3, 3, 0, 0, 3, 3, 1, 1, 0, 3, 1};
    double zs[n_nodes] = {0, 0, 0, 0, 3, 3, 3, 3, 5, 5, 3, 3, 5};

    int sizeof_data = sizeof(double);
    int sizeof_geom = sizeof(double);
    const int exid = ex_create("four.e", EX_CLOBBER, &sizeof_data, &sizeof_geom);

    const int dim = 3;
    const int n_blocks = n_elems;
    const int n_node_sets = 0;
    const int n_side_sets = 0;
    int ierr = ex_put_init(exid, "mytitle", dim, n_nodes, n_elems, n_blocks,
                           n_node_sets, n_side_sets);
    assert(ierr == 0);

    // nodes:
    ierr = ex_put_coord(exid, xs, ys, zs);
    assert(ierr == 0);

    // block 0 (hex):
    ierr = ex_put_elem_block(exid, 1, "hex", 1, 8, 0);
    assert(ierr == 0);
    // block 1 (pyramid):
    ierr = ex_put_elem_block(exid, 10, "pyramid", 1, 5, 0);
    assert(ierr == 0);
    // block 2 (tet):
    ierr = ex_put_elem_block(exid, 100, "tet", 1, 4, 0);
    assert(ierr == 0);
    // block 3 (wedge):
    ierr = ex_put_elem_block(exid, 1000, "wedge", 1, 6, 0);
    assert(ierr == 0);

    // connectivity:
    ierr = ex_put_elem_conn(exid, 1, elements_1);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 10, elements_2);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 100, elements_3);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 1000, elements_4);
    assert(ierr == 0);

    ierr = ex_close(exid);
    assert(ierr == 0);
}

Check that we can truncate higher-order elements correctly (like PYRAMID14 ->
our five-point pyramid)

#include <exodusII.h>

#include <algorithm>
#include <cassert>
#include <cstring>

int main()
{
    const int n_elems = 4;
    const int n_nodes = 29;
    int elements_1[1][20] = {{1, 2, 3, 4, 5, 6, 7, 8, 17, 14, 15, 16, 21, 18, 19, 20, 25, 22, 23, 24}};
    // int elements_1[1][8] = {{1, 2, 3, 4, 5, 6, 7, 8}};
    int elements_2[1][13] = {{5, 6, 7, 8, 9, 25, 22, 23, 24, 26, 27, 28, 29}};
    int elements_3[1][4] = {{6, 10, 7, 9}};
    int elements_4[1][6] = {{10, 6, 7, 13, 11, 12}};

    double xs[n_nodes] = {0, 3, 3, 0, 0, 3, 3, 0, 1, 3, 8, 8, 8, 3, 1.5, 0, 1.5, 3, 3, 0, 0, 3, 1.5, 0, 1.5, 0.5, 2, 2, 0.5};
    double ys[n_nodes] = {0, 0, 3, 3, 0, 0, 3, 3, 1, 1, 0, 3, 1, 1.5, 3, 1.5, 0, 0, 3, 3, 0, 1.5, 3, 1.5, 0, 0.5, 0.5, 2, 2};
    double zs[n_nodes] = {0, 0, 0, 0, 3, 3, 3, 3, 5, 5, 3, 3, 5, 0, 0, 0, 0, 1.5, 1.5, 1.5, 1.5, 3, 3, 3, 3, 4, 4, 4, 4};

    int sizeof_data = sizeof(double);
    int sizeof_geom = sizeof(double);
    const int exid = ex_create("four-p.e", EX_CLOBBER, &sizeof_data, &sizeof_geom);

    const int dim = 3;
    const int n_blocks = n_elems;
    const int n_node_sets = 0;
    const int n_side_sets = 0;
    int ierr = ex_put_init(exid, "mytitle", dim, n_nodes, n_elems, n_blocks,
                           n_node_sets, n_side_sets);
    assert(ierr == 0);

    // nodes:
    ierr = ex_put_coord(exid, xs, ys, zs);
    assert(ierr == 0);

    // block 0 (hex):
    ierr = ex_put_elem_block(exid, 1, "hex20", 1, 20, 0);
    assert(ierr == 0);
    // block 1 (pyramid):
    ierr = ex_put_elem_block(exid, 10, "pyramid13", 1, 13, 0);
    assert(ierr == 0);
    // block 2 (tet):
    ierr = ex_put_elem_block(exid, 100, "tet", 1, 4, 0);
    assert(ierr == 0);
    // block 3 (wedge):
    ierr = ex_put_elem_block(exid, 1000, "wedge", 1, 6, 0);
    assert(ierr == 0);

    // connectivity:
    ierr = ex_put_elem_conn(exid, 1, elements_1);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 10, elements_2);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 100, elements_3);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 1000, elements_4);
    assert(ierr == 0);

    ierr = ex_close(exid);
    assert(ierr == 0);
}

Get things working with a nonzero codimension:

#include <exodusII.h>

#include <algorithm>
#include <cassert>
#include <cstring>

// Create a disk mesh with five quadrilaterals.
//
//  ____________________________
// |\                          /|
// | \                        / |
// |  \           3          /  |
// |   \                    /   |
// |    \                  /    |
// |     \                /     |
// |      \______________/      |
// |      |              |      |
// |      |              |      |
// |      |              |      |
// |   4  |      5       |   2  |
// |      |              |      |
// |      |______________|      |
// |      /              \      |
// |     /                \     |
// |    /                  \    |
// |   /                    \   |
// |  /          1           \  |
// | /                        \ |
// |/                          \|
// -----------------------------
//
// element 1 has external side sets 0, 1
// element 2 has external side sets 0, 1, 10
// element 3 has no external side sets
// element 4 has no external side set 0
//
// The inner element is in block 10 - the rest are in block 1.
int main()
{
    const int n_elems = 5;
    const int n_nodes = 8;
    int elements_1[n_elems - 1][4] = {
    {1, 2, 3, 4},
    {1, 4, 5, 6},
    {2, 8, 7, 3},
    {6, 5, 7, 8}};
    int elements_10[1][4] = {{4, 3, 7, 5}};

    double xs[n_nodes] = {0, 7, 5, 2, 2, 0, 5, 7};
    double ys[n_nodes] = {0, 0, 2, 2, 5, 7, 5, 7};

    int sizeof_data = sizeof(double);
    int sizeof_geom = sizeof(double);
    const int exid = ex_create("five-3d.e", EX_CLOBBER, &sizeof_data, &sizeof_geom);

    const int dim = 3;
    const int n_blocks = 2;
    const int n_node_sets = 0;
    const int n_side_sets = 3;
    int ierr = ex_put_init(exid, "mytitle", dim, n_nodes, n_elems, n_blocks,
                           n_node_sets, n_side_sets);
    assert(ierr == 0);

    // nodes:
    ierr = ex_put_coord(exid, xs, ys, xs);
    assert(ierr == 0);

    // element blocks:
    ierr = ex_put_elem_block(exid, 1, "quad", 4, 4, 0);
    assert(ierr == 0);
    ierr = ex_put_elem_block(exid, 10, "quad", 1, 4, 0);
    assert(ierr == 0);

    ierr = ex_put_elem_conn(exid, 10, elements_10);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 1, elements_1);
    assert(ierr == 0);

    // side sets:
    ierr = ex_put_side_set_param(exid, 0, 3, 0);
    assert(ierr == 0);
    int sideset_0_elems[] = {1, 2, 4};
    int sideset_0_sides[] = {3, 4, 6};
    ierr = ex_put_side_set(exid, 0, sideset_0_elems, sideset_0_sides);
    assert(ierr == 0);

    ierr = ex_put_side_set_param(exid, 1, 2, 0);
    assert(ierr == 0);
    int sideset_1_elems[] = {1, 2};
    int sideset_1_sides[] = {3, 4};
    ierr = ex_put_side_set(exid, 1, sideset_1_elems, sideset_1_sides);
    assert(ierr == 0);

    ierr = ex_put_side_set_param(exid, 10, 1, 0);
    assert(ierr == 0);
    int sideset_10_elems[] = {2};
    int sideset_10_sides[] = {4};
    ierr = ex_put_side_set(exid, 10, sideset_10_elems, sideset_10_sides);
    assert(ierr == 0);

    ierr = ex_close(exid);
    assert(ierr == 0);
}

Check sidesets in 3D:

#include <exodusII.h>

#include <algorithm>
#include <cassert>
#include <cstring>

// Like writer-2 but with side sets.

int main()
{
    const int n_elems = 4;
    const int n_nodes = 13;
    int elements_1[1][8] = {{1, 2, 3, 4, 5, 6, 7, 8}};
    int elements_2[1][5] = {{5, 6, 7, 8, 9}};
    int elements_3[1][4] = {{6, 10, 7, 9}};
    int elements_4[1][6] = {{10, 6, 7, 13, 11, 12}};

    double xs[n_nodes] = {0, 3, 3, 0, 0, 3, 3, 0, 1, 3, 8, 8, 8};
    double ys[n_nodes] = {0, 0, 3, 3, 0, 0, 3, 3, 1, 1, 0, 3, 1};
    double zs[n_nodes] = {0, 0, 0, 0, 3, 3, 3, 3, 5, 5, 3, 3, 5};

    int sizeof_data = sizeof(double);
    int sizeof_geom = sizeof(double);
    const int exid = ex_create("four-sidesets.e", EX_CLOBBER, &sizeof_data, &sizeof_geom);

    const int dim = 3;
    const int n_blocks = n_elems;
    const int n_node_sets = 0;
    const int n_side_sets = 5;
    int ierr = ex_put_init(exid, "mytitle", dim, n_nodes, n_elems, n_blocks,
                           n_node_sets, n_side_sets);
    assert(ierr == 0);

    // nodes:
    ierr = ex_put_coord(exid, xs, ys, zs);
    assert(ierr == 0);

    // block 0 (hex):
    ierr = ex_put_elem_block(exid, 1, "hex", 1, 8, 0);
    assert(ierr == 0);
    // block 1 (pyramid):
    ierr = ex_put_elem_block(exid, 10, "pyramid", 1, 5, 0);
    assert(ierr == 0);
    // block 2 (tet):
    ierr = ex_put_elem_block(exid, 100, "tet", 1, 4, 0);
    assert(ierr == 0);
    // block 3 (wedge):
    ierr = ex_put_elem_block(exid, 1000, "wedge", 1, 6, 0);
    assert(ierr == 0);

    // connectivity:
    ierr = ex_put_elem_conn(exid, 1, elements_1);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 10, elements_2);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 100, elements_3);
    assert(ierr == 0);
    ierr = ex_put_elem_conn(exid, 1000, elements_4);
    assert(ierr == 0);

    // side sets:
    ierr = ex_put_side_set_param(exid, 1, 5, 0);
    assert(ierr == 0);
    int sideset_1_elems[] = {1, 1, 2, 3, 4};
    int sideset_1_sides[] = {1, 5, 1, 1, 1};
    ierr = ex_put_side_set(exid, 1, sideset_1_elems, sideset_1_sides);
    assert(ierr == 0);

    ierr = ex_put_side_set_param(exid, 2, 3, 0);
    assert(ierr == 0);
    int sideset_2_elems[] = {1, 3, 4};
    int sideset_2_sides[] = {2, 2, 2};
    ierr = ex_put_side_set(exid, 2, sideset_2_elems, sideset_2_sides);
    assert(ierr == 0);

    ierr = ex_put_side_set_param(exid, 3, 3, 0);
    assert(ierr == 0);
    int sideset_3_elems[] = {1, 2, 4};
    int sideset_3_sides[] = {3, 3, 3};
    ierr = ex_put_side_set(exid, 3, sideset_3_elems, sideset_3_sides);
    assert(ierr == 0);

    ierr = ex_put_side_set_param(exid, 4, 2, 0);
    assert(ierr == 0);
    int sideset_4_elems[] = {1, 2};
    int sideset_4_sides[] = {4, 4};
    ierr = ex_put_side_set(exid, 4, sideset_4_elems, sideset_4_sides);
    assert(ierr == 0);

    ierr = ex_put_side_set_param(exid, 5, 4, 0);
    assert(ierr == 0);
    int sideset_5_elems[] = {1, 1, 2, 4};
    int sideset_5_sides[] = {4, 5, 4, 5};
    ierr = ex_put_side_set(exid, 5, sideset_5_elems, sideset_5_sides);
    assert(ierr == 0);

    ierr = ex_close(exid);
    assert(ierr == 0);
}

Functions of hp::Refinement now only available for DoFHandler in hp mode.

Improve VectorDataExchange::Full::reset_ghost_values

Fix fe_face_evaluation_process_and_io for multiple components

Move n_vertices_to_type to reference_cell.h

Check for SEACAS support.

We need it for ExodusII.

Merge pull request #11151 from peterrum/SolverCGSM

Fix sm-mode L:d:V for zero sized vectors

Merge pull request #11109 from tjhei/mpi_comm_ref

pass MPI_Comm by const ref

Fix compute_shared_memory_contiguous_indices

Fix SolverCG for sm-mode L:d:V

Merge pull request #11150 from peterrum/mpi_processes_within_communicator_use

Use mpi_processes_within_communicator

Use mpi_processes_within_communicator

Merge pull request #11097 from peterrum/dof_indices_contiguous_sm_io

Use dof_indices_contiguous_sm in evaluation functions

Merge pull request #11145 from mathsen/multigrid_inh_boundary_conditions

Adjusted mg_constrained_dofs for usage of own IndexSets

Merge pull request #11131 from tamiko/add_a_test

Transfinite interpolation: add a test

indent

Merge pull request #11141 from peterrum/ImplementationMixedMesh

Add internal::TriangulationImplementation::ImplementationMixedMesh

Update tests/manifold/transfinite_manifold_11.cc

Co-authored-by: Martin Kronbichler <kronbichler@lnm.mw.tum.de>

Different fixes

Merge pull request #11147 from peterrum/simplify_categorize_by_boundary_ids

Simplify simplify_categorize_by_boundary_ids

Simplify simplify_categorize_by_boundary_ids

added proposed changes

Merge pull request #11134 from luca-heltai/bug-anisotropic

Expose mesh loop bug for anisotropic grids.

Add internal::TriangulationImplementation::ImplementationMixedMesh

Merge pull request #11140 from peterrum/tria_reference_type

Store reference_cell_types in Triangulation

unified both initialize() functions into one with default second argument

Merge pull request #11143 from tjhei/step_7_double

step-7: mark some ints as doubles

Merge pull request #11144 from drwells/class-to-function

Label functions as such (and not as classes).

Adjusted mg_constrained_dofs for usage of own IndexSet, so that the user can add additional constrained DoFs to the MGConstrainedDoFs class.

Label functions as such (and not as classes).

step-7: mark some ints as doubles

Store reference_types in Triangulation

Merge pull request #11139 from bangerth/invalid

Avoid the use of 'illegal' in error messages.

Merge pull request #11123 from marcfehling/hp-capability-enabled

Hide hp_capability_enabled parameter.

TransfiniteInterpolation: also print point in test

Transfinite interpolation: add a test

Avoid the use of 'illegal' in error messages.

There is nothing against the law anyone is trying to do, it's just not a
valid operation.

Merge pull request #11137 from peterrum/mpi_processes_within_communicator

Introduce Utilities::MPI::mpi_processes_within_communicator

Merge pull request #11136 from peterrum/initialize_indices_global_active_cell_index

Use global_active_cell_index in MatrixFree::initialize_indices

Merge pull request #11135 from peterrum/global_active_cell_index_comments

Extend docu on global_active_cell_index

Merge pull request #11098 from peterrum/vde_full

Introduce VectorDataExchange::Full

Merge pull request #11125 from lethe-cfd/update_ghost_particles

Update ghost particles without rebuilding them

Introduce Utilities::MPI::mpi_processes_within_communicator

Expose mesh loop bug for anisotropic grids.

Use global_active_cell_index in MatrixFree::initialize_indices

Extend docu on global_active_cell_index

Introduce VectorDataExchange::Full and introduce 2nd communicator in MatrixFree

Merge pull request #11092 from peterrum/dof_indices_contiguous_sm

MatrixFree: add DoFInfo::dof_indices_contiguous_sm

Merge pull request #11103 from peterrum/simplex_q_gauss_1D

Pass n_q_points_1D to Simplex::QGauss

Merge pull request #10490 from peterrum/cell_global_id

Give each cell a globally unique (level) ID

MatrixFree: add DoFInfo::dof_indices_contiguous_sm

Merge pull request #11126 from kronbichler/fix_transfinite_jacobian

Transfinite interpolation: Fix refresh of Jacobian

Added unit test
Improved documentation

Merge pull request #11130 from mathsen/reorder_mg

set number_cache.n_global_dofs to the right size in MultiGrid scenario

Merge pull request #11127 from kronbichler/transfinite_quadratic_approximation

Transfinite interpolation: inverse quadratic approximation in pull-back

Hide hp_capability_enabled parameter.

Merge pull request #11129 from tjhei/rotation_matrix_type_fix

fix type in Physics rotation_matrix_2d and 3d

Pass n_q_points_1D to Simplex::QGauss

Give each cell a globally unique (level) ID

fix type in Physics rotation_matrix_2d and 3d

The values were computed as doubles, which means this function can not
be used with Number=float (no constructor for Tensor exists). Fix this.

set number_cache.n_global_dofs to the right size in MultiGrid scenario

Merge pull request #10439 from peterrum/tria_impl_merge

Introduce internal::TriangulationImplementation::Policy

Changelog

Transfinite interpolation: Use inverse quadratic approximation for pull_back

Transfinite interpolation: Fix refresh of Jacobian

Merge pull request #11121 from drwells/pyramid-wedge-face-vertices

Implement face_to_cell_vertices for pyramids and wedges.

First version of an update_ghost_particles
Does not contain any modification to send_recv

Implement face_to_cell_vertices for pyramids and wedges.

Merge pull request #11116 from masterleinad/fix_cudwrappers_used_objects

Fix multiple definitions for CUDAWrappes::internal::used_objects

pass MPI_Comm by const ref

fixes #11107

Update source/matrix_free/cuda_matrix_free.cu

Co-authored-by: David Wells <drwells@email.unc.edu>

Merge pull request #11118 from drwells/fix-wedge-n_faces

Fix Wedge::n_faces().

Fix Wedge::n_faces().

Wedges have five faces.

Fix multiple definitions for CUDAWrappes::internal::used_objects

Merge pull request #11113 from kronbichler/avoid_invalid_reference

Do not capture by reference in range-based for over IndexSet

Merge pull request #11090 from eliasstudiert/simplex_write_svg

Extend GridOut::write_svg() for simplices

Another one

Do not capture by reference for iota_view

Merge pull request #11114 from kronbichler/remove_symmetric_tensor

Switch SymmetricTensor -> Tensor for better performance

Switch SymmetricTensor -> Tensor for better performance.

Remove yet another capture by reference in IndexSet

Remove another capture by reference

Do not use a reference in range-based for over IndexSet

Merge pull request #11074 from peterrum/ldv_shmem

Introduce MPI-3 shared-memory capabilities in L:d:V

Merge pull request #11104 from lethe-cfd/exchange_ghost_particles_optimization

Exchange ghost particles optimization by not rebuilding vertex_to_neighbor_subdomain

Merge pull request #11085 from kronbichler/inverse_quadratic_approximation

Inverse quadratic approximation for MappingQ::real_to_unit_cell

Introduce MPI-3 shared-memory capabilities in L:d:V

Merge pull request #11099 from jppelteret/step_44_update_assembly_01

Step 44: Unify assembly loop and introduce an optimisation

Construct approximation by two sets of points.

Also better document some variables and mark constant variables as const.