283 for (
unsigned int face =
range.first; face <
range.second; ++face)
296 [&](
const auto &
data,
auto &dst,
const auto &src,
const auto range) {
301 for (
unsigned int face =
range.first; face <
range.second; ++face)
319 [&](
const auto &
data,
auto &dst,
const auto &src,
const auto range) {
324 for (
unsigned int cell =
range.first; cell <
range.second; ++cell)
336 if (
data.get_faces_by_cells_boundary_id(cell, face)[0] ==
340 phi_m.reinit(cell, face);
342 phi_p.reinit(cell, face);
352 phi_m.reinit(cell, face);
381additional_data.hold_all_faces_to_owned_cells =
true;
382additional_data.mapping_update_flags_faces_by_cells =
383 additional_data.mapping_update_flags_inner_faces |
384 additional_data.mapping_update_flags_boundary_faces;
386data.reinit(mapping, dof_handler,
constraint, quadrature, additional_data);
390for all faces
of the cells.
412 const VectorType & src,
413 const std::pair<unsigned int, unsigned int> &
range)
const
416 for (
unsigned int cell =
range.first; cell <
range.second; ++cell)
429matrix_free.cell_loop(&Operator::local_apply_cell,
this, dst, src);
437 [&](
const auto &
data,
auto &dst,
const auto &src,
const auto range) {
439 for (
unsigned int cell =
range.first; cell <
range.second; ++cell)
453<a name=
"step_76-VectorizedArrayType"></a><
h3>VectorizedArrayType</
h3>
472<table align="center" class="doxtable">
481 <td>(auto-vectorization)</td>
503degrees (and dimensions).
515<table align="center" class="doxtable">
518 <th>std::simd (C++23)</th>
522 <td><code>std::experimental::native_simd<Number></code></td>
526 <td><code>std::experimental::fixed_size_simd<Number, size></code></td>
531 * <a name="step_76-CommProg"></a>
535 * <a name="step_76-Parametersandutilityfunctions"></a>
543 *
 #
include <deal.II/base/conditional_ostream.h>
544 *
 #
include <deal.II/base/function.h>
545 *
 #
include <deal.II/base/time_stepping.h>
547 *
 #
include <deal.II/base/utilities.h>
548 *
 #
include <deal.II/base/vectorization.h>
550 *
 #
include <deal.II/distributed/tria.h>
552 *
 #
include <deal.II/dofs/dof_handler.h>
555 *
 #
include <deal.II/fe/fe_system.h>
557 *
 #
include <deal.II/grid/grid_generator.h>
559 *
 #
include <deal.II/grid/tria_accessor.h>
560 *
 #
include <deal.II/grid/tria_iterator.h>
562 *
 #
include <deal.II/lac/affine_constraints.h>
563 *
 #
include <deal.II/lac/la_parallel_vector.h>
565 *
 #
include <deal.II/matrix_free/fe_evaluation.h>
566 *
 #
include <deal.II/matrix_free/matrix_free.h>
567 *
 #
include <deal.II/matrix_free/operators.h>
569 *
 #
include <deal.II/numerics/data_out.h>
580 *
 #
include <deal.II/matrix_free/tools.h>
590 *
The same input parameters
as in @
ref step_67
"step-67":
594 *
 constexpr unsigned int dimension = 2;
596 *
 constexpr unsigned int fe_degree = 5;
597 *
 constexpr unsigned int n_q_points_1d = fe_degree + 2;
609 *
 using Number = double;
629 *
 constexpr double gamma = 1.4;
630 *
 constexpr double final_time =
testcase == 0 ? 10 : 2.0;
686 *
 std::vector<double>
ci;
690 *
 unsigned int n_stages()
const
692 *
 return bi.size();
695 *
 template <
typename VectorType,
typename Operator>
697 *
 const double current_time,
699 *
 VectorType &solution,
728 *
 std::vector<double>
bi;
729 *
 std::vector<double>
ai;
747 *
 template <
int dim>
756 *
 const unsigned int component = 0)
const override;
761 *
 template <
int dim>
763 *
 const unsigned int component)
const
771 *
 Assert(dim == 2, ExcNotImplemented());
772 *
 const double beta = 5;
778 *
 const double factor =
781 *
 std::abs(1. - (gamma - 1.) / gamma * 0.25 * factor * factor));
783 *
 const double u = 1. - factor * (
x[1] -
x0[1]);
784 *
 const double v = factor * (
x[0] - t -
x0[0]);
786 *
 if (component == 0)
788 *
 else if (component == 1)
790 *
 else if (component == 2)
803 *
 if (component == 0)
805 *
 else if (component == 1)
807 *
 else if (component == dim + 1)
808 *
 return 3.097857142857143;
821 *
 template <
int dim,
typename Number>
829 *
 for (
unsigned int d = 0;
d < dim; ++
d)
835 *
 template <
int dim,
typename Number>
844 *
 for (
unsigned int d = 1;
d < dim; ++
d)
850 *
 template <
int dim,
typename Number>
860 *
 for (
unsigned int d = 0;
d < dim; ++
d)
863 *
 for (
unsigned int e = 0;
e < dim; ++
e)
873 *
 template <
int n_components,
int dim,
typename Number>
880 *
 for (
unsigned int d = 0;
d < n_components; ++
d)
881 *
 result[d] = matrix[d] * vector;
885 *
 template <
int dim,
typename Number>
912 *
 0.5 * lambda * (
u_m -
u_p);
948 *
 template <
int dim,
typename VectorizedArrayType>
949 *
 VectorizedArrayType
952 *
 const unsigned int component)
954 *
 VectorizedArrayType
result;
955 *
 for (
unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
958 *
 for (
unsigned int d = 0;
d < dim; ++
d)
960 *
 result[v] = function.value(p, component);
966 *
 template <
int dim,
typename VectorizedArrayType,
int n_components = dim + 2>
973 *
 for (
unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
976 *
 for (
unsigned int d = 0;
d < dim; ++
d)
978 *
 for (
unsigned int d = 0;
d < n_components; ++
d)
979 *
 result[d][v] = function.value(p, d);
988 * <a name=
"step_76-EuleroperatorusingacellcentricloopandMPI30sharedmemory"></a>
996 *
 template <
int dim,
int degree,
int n_po
ints_1d>
1023 *
 const Number
bi,
1024 *
 const Number
ai,
1116 *
 template <
int dim,
int degree,
int n_po
ints_1d>
1138 *
 const std::vector<const DoFHandler<dim> *> dof_handlers = {&dof_handler};
1140 *
 const std::vector<const AffineConstraints<double> *> constraints = {&dummy};
1145 *
 additional_data;
1146 *
 additional_data.mapping_update_flags =
1149 *
 additional_data.mapping_update_flags_inner_faces =
1152 *
 additional_data.mapping_update_flags_boundary_faces =
1155 *
 additional_data.tasks_parallel_scheme =
1167 *
 MatrixFreeTools::categorize_by_boundary_ids(dof_handler.get_triangulation(),
1168 *
 additional_data);
1179 *
 mapping, dof_handlers, constraints,
quadratures, additional_data);
1213 *
 const Number current_time,
1221 *
 i.
second->set_time(current_time);
1223 *
 i.
second->set_time(current_time);
1240 *
 VectorizedArrayType>;
1246 *
 VectorizedArrayType>;
1267 *
 VectorizedArrayType,
1270 *
 data.get_shape_info().
data[0].shape_gradients_collocation_eo,
1274 *
 phi.n_components);
1284 *
 phi.reinit(cell);
1286 *
 if (
ai != Number())
1292 * quadrature points:
1295 *
 if (
ai != Number() &&
stage == 0)
1297 *
 phi.read_dof_values(src);
1299 *
 for (
unsigned int i = 0;
1300 *
 i <
phi.static_dofs_per_component * (dim + 2);
1302 *
 phi_temp.begin_dof_values()[i] =
phi.begin_dof_values()[i];
1318 *
 for (
unsigned int i = 0; i <
phi.static_n_q_points * (dim + 2); ++i)
1325 * @
ref step_67 "step-67":
1328 *
 for (
const unsigned int q :
phi.quadrature_point_indices())
1330 *
 const auto w_q =
phi.get_value(
q);
1341 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1343 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1356 *
as the final step.
1363 *
 for (
unsigned int c = 0; c < dim + 2; ++c)
1368 *
 else if (dim >= 1)
1390 *
 for (
unsigned int face = 0;
1402 *
 const auto boundary_ids =
1403 *
 data.get_faces_by_cells_boundary_id(cell, face);
1405 *
 Assert(std::equal(boundary_ids.begin(),
1406 *
 boundary_ids.begin() +
1407 *
 data.n_active_entries_per_cell_batch(cell),
1408 *
 boundary_ids.begin()),
1409 *
 ExcMessage(
"Boundary IDs of lanes differ."));
1413 *
 phi_m.reinit(cell, face);
1424 *
 VectorizedArrayType>::
1428 *
 data.get_shape_info(),
1430 *
 phi_m.begin_values(),
1445 * <
code>EulerDG::EulerOperator::local_apply_face</
code>
1446 *
from @
ref step_67
"step-67":
1449 *
 phi_p.reinit(cell, face);
1452 *
 for (
const unsigned int q :
1453 *
 phi_m.quadrature_point_indices())
1468 * <
code>EulerDG::EulerOperator::local_apply_boundary_face</
code>
1469 *
from @
ref step_67
"step-67":
1472 *
 for (
const unsigned int q :
1473 *
 phi_m.quadrature_point_indices())
1476 *
 const auto normal =
phi_m.normal_vector(
q);
1479 *
 for (
unsigned int d = 1;
d < dim; ++
d)
1490 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1493 *
 w_p[dim + 1] =
w_m[dim + 1];
1499 *
 phi_m.quadrature_point(
q));
1507 *
 .find(boundary_id)
1509 *
 phi_m.quadrature_point(
q),
1516 *
 "Unknown boundary id, did "
1517 *
 "you set a boundary condition for "
1518 *
 "this part of the domain boundary?"));
1523 *
 for (
unsigned int v = 0;
1524 *
 v < VectorizedArrayType::size();
1528 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1529 *
 flux[d + 1][v] = 0.;
1544 *
 VectorizedArrayType>::
1548 *
 data.get_shape_info(),
1549 *
 phi_m.begin_values(),
1550 *
 phi.begin_values(),
1558 * <
code>EulerDG::EulerOperator::local_apply_inverse_mass_matrix()</
code>
1559 *
from @
ref step_67
"step-67":
1562 *
 for (
unsigned int q = 0;
q <
phi.static_n_q_points; ++
q)
1564 *
 const auto factor = VectorizedArrayType(1.0) /
phi.JxW(
q);
1565 *
 for (
unsigned int c = 0; c < dim + 2; ++c)
1566 *
 phi.begin_values()[c *
phi.static_n_q_points +
q] =
1567 *
 phi.begin_values()[c *
phi.static_n_q_points +
q] * factor;
1582 *
 data.get_shape_info()
1584 *
 .inverse_shape_values_eo,
1586 *
 phi.begin_values(),
1587 *
 phi.begin_dof_values());
1595 *
 if (
ai == Number())
1597 *
 for (
unsigned int q = 0;
q <
phi.static_dofs_per_cell; ++
q)
1598 *
 phi.begin_dof_values()[
q] =
bi *
phi.begin_dof_values()[
q];
1599 *
 phi.distribute_local_to_global(solution);
1606 *
 for (
unsigned int q = 0;
q <
phi.static_dofs_per_cell; ++
q)
1608 *
 const auto K_i =
phi.begin_dof_values()[
q];
1610 *
 phi.begin_dof_values()[
q] =
1615 *
 phi.set_dof_values(dst);
1633 *
 template <
int dim,
int degree,
int n_po
ints_1d>
1637 *
 data.initialize_dof_vector(vector);
1642 *
 template <
int dim,
int degree,
int n_po
ints_1d>
1650 *
 ExcMessage(
"You already set the boundary with id " +
1651 *
 std::to_string(
static_cast<int>(boundary_id)) +
1652 *
 " to another type of boundary before now setting " +
1653 *
 "it as inflow"));
1655 *
 ExcMessage(
"Expected function with dim+2 components"));
1662 *
 template <
int dim,
int degree,
int n_po
ints_1d>
1670 *
 ExcMessage(
"You already set the boundary with id " +
1671 *
 std::to_string(
static_cast<int>(boundary_id)) +
1672 *
 " to another type of boundary before now setting " +
1673 *
 "it as subsonic outflow"));
1675 *
 ExcMessage(
"Expected function with dim+2 components"));
1682 *
 template <
int dim,
int degree,
int n_po
ints_1d>
1690 *
 ExcMessage(
"You already set the boundary with id " +
1691 *
 std::to_string(
static_cast<int>(boundary_id)) +
1692 *
 " to another type of boundary before now setting " +
1693 *
 "it as wall boundary"));
1700 *
 template <
int dim,
int degree,
int n_po
ints_1d>
1711 *
 template <
int dim,
int degree,
int n_po
ints_1d>
1722 *
 VectorizedArrayType>
1724 *
 solution.zero_out_ghost_values();
1725 *
 for (
unsigned int cell = 0; cell <
data.n_cell_batches(); ++cell)
1727 *
 phi.reinit(cell);
1728 *
 for (
const unsigned int q :
phi.quadrature_point_indices())
1730 *
 phi.quadrature_point(
q)),
1732 *
 inverse.transform_from_q_points_to_basis(dim + 2,
1733 *
 phi.begin_dof_values(),
1734 *
 phi.begin_dof_values());
1735 *
 phi.set_dof_values(solution);
1741 *
 template <
int dim,
int degree,
int n_po
ints_1d>
1751 *
 for (
unsigned int cell = 0; cell <
data.n_cell_batches(); ++cell)
1753 *
 phi.reinit(cell);
1756 *
 for (
const unsigned int q :
phi.quadrature_point_indices())
1760 *
 phi.get_value(
q);
1761 *
 const auto JxW =
phi.JxW(
q);
1764 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1768 *
 for (
unsigned int v = 0; v <
data.n_active_entries_per_cell_batch(cell);
1770 *
 for (
unsigned int d = 0;
d < 3; ++
d)
1776 *
 std::array<double, 3>
errors;
1777 *
 for (
unsigned int d = 0;
d < 3; ++
d)
1785 *
 template <
int dim,
int degree,
int n_po
ints_1d>
1794 *
 for (
unsigned int cell = 0; cell <
data.n_cell_batches(); ++cell)
1796 *
 phi.reinit(cell);
1799 *
 for (
const unsigned int q :
phi.quadrature_point_indices())
1805 *
 const auto inverse_jacobian =
phi.inverse_jacobian(
q);
1808 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1816 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1818 *
 for (
unsigned int i = 0; i < 5; ++i)
1823 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1836 *
 for (
unsigned int v = 0; v <
data.n_active_entries_per_cell_batch(cell);
1848 *
 template <
int dim>
1886 *
 virtual void evaluate_vector_field(
1890 *
 virtual std::vector<std::string> get_names()
const override;
1892 *
 virtual std::vector<
1894 *
 get_data_component_interpretation()
const override;
1896 *
 virtual UpdateFlags get_needed_update_flags()
const override;
1905 *
 template <
int dim>
1912 *
 template <
int dim>
1921 *
 ExcInternalError());
1924 *
 ExcInternalError());
1925 *
 Assert(
inputs.solution_values[0].size() == dim + 2, ExcInternalError());
1928 *
 ExcInternalError());
1933 *
 for (
unsigned int d = 0;
d < dim + 2; ++
d)
1934 *
 solution[d] =
inputs.solution_values[p](d);
1936 *
 const double density = solution[0];
1940 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1947 *
 inputs.solution_gradients[p][0] *
inputs.solution_gradients[p][0];
1953 *
 template <
int dim>
1956 *
 std::vector<std::string> names;
1957 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1958 *
 names.emplace_back(
"velocity");
1959 *
 names.emplace_back(
"pressure");
1960 *
 names.emplace_back(
"speed_of_sound");
1963 *
 names.emplace_back(
"schlieren_plot");
1970 *
 template <
int dim>
1971 *
 std::vector<DataComponentInterpretation::DataComponentInterpretation>
1974 *
 std::vector<DataComponentInterpretation::DataComponentInterpretation>
1976 *
 for (
unsigned int d = 0;
d < dim; ++
d)
1991 *
 template <
int dim>
2002 *
 template <
int dim>
2009 *
 , mapping(fe_degree)
2019 *
 template <
int dim>
2027 *
 for (
unsigned int d = 1;
d < dim; ++
d)
2032 *
 for (
unsigned int d = 1;
d < dim; ++
d)
2062 *
 std::vector<double>({0., 0., -0.2})));
2073 *
 dof_handler.distribute_dofs(fe);
2078 *
 std::locale s =
pcout.get_stream().getloc();
2079 *
 pcout.get_stream().imbue(std::locale(
""));
2080 *
 pcout <<
"Number of degrees of freedom: " << dof_handler.n_dofs()
2081 *
 <<
" ( = " << (dim + 2) <<
" [vars] x "
2085 *
 pcout.get_stream().imbue(s);
2090 *
 template <
int dim>
2093 *
 const std::array<double, 3>
errors =
2097 *
 pcout <<
"Time:" << std::setw(8) << std::setprecision(3) << time
2098 *
 <<
", dt: " << std::setw(8) << std::setprecision(2) <<
time_step
2100 *
 << std::setw(10) <<
errors[0] <<
", rho * u: " << std::setprecision(4)
2101 *
 << std::setw(10) <<
errors[1] <<
", energy:" << std::setprecision(4)
2102 *
 << std::setw(10) <<
errors[2] << std::endl;
2111 *
 flags.write_higher_order_cells =
true;
2112 *
 data_out.set_flags(flags);
2114 *
 data_out.attach_dof_handler(dof_handler);
2116 *
 std::vector<std::string> names;
2117 *
 names.emplace_back(
"density");
2118 *
 for (
unsigned int d = 0;
d < dim; ++
d)
2119 *
 names.emplace_back(
"momentum");
2120 *
 names.emplace_back(
"energy");
2122 *
 std::vector<DataComponentInterpretation::DataComponentInterpretation>
2126 *
 for (
unsigned int d = 0;
d < dim; ++
d)
2132 *
 data_out.add_data_vector(dof_handler, solution, names,
interpretation);
2134 *
 data_out.add_data_vector(solution, postprocessor);
2139 *
 reference.reinit(solution);
2141 *
 reference.sadd(-1., 1, solution);
2142 *
 std::vector<std::string> names;
2143 *
 names.emplace_back(
"error_density");
2144 *
 for (
unsigned int d = 0;
d < dim; ++
d)
2145 *
 names.emplace_back(
"error_momentum");
2146 *
 names.emplace_back(
"error_energy");
2148 *
 std::vector<DataComponentInterpretation::DataComponentInterpretation>
2152 *
 for (
unsigned int d = 0;
d < dim; ++
d)
2158 *
 data_out.add_data_vector(dof_handler,
2166 *
 data_out.add_data_vector(
mpi_owner,
"owner");
2168 *
 data_out.build_patches(mapping,
2180 *
 template <
int dim>
2184 *
 const unsigned int n_vect_number = VectorizedArrayType::size();
2187 *
 pcout <<
"Running with "
2189 *
 <<
" MPI processes" << std::endl;
2191 *
 << (std::is_same_v<Number, double> ?
"doubles" :
"floats") <<
" = "
2210 *
 for (
const auto &cell :
triangulation.active_cell_iterators())
2211 *
 if (cell->is_locally_owned())
2221 *
 <<
", initial transport scaling: "
2253 *
 time >= final_time - 1e-12)
2255 *
 static_cast<unsigned int>(std::round(time /
output_tick)));
2277 *
 catch (std::exception &exc)
2279 *
 std::cerr << std::endl
2281 *
 <<
"----------------------------------------------------"
2283 *
 std::cerr <<
"Exception on processing: " << std::endl
2284 *
 << exc.what() << std::endl
2285 *
 <<
"Aborting!" << std::endl
2286 *
 <<
"----------------------------------------------------"
2293 *
 std::cerr << std::endl
2295 *
 <<
"----------------------------------------------------"
2297 *
 std::cerr <<
"Unknown exception!" << std::endl
2298 *
 <<
"Aborting!" << std::endl
2299 *
 <<
"----------------------------------------------------"
2316Number
of degrees
of freedom: 27.648.000 ( = 5 [vars]
x 25.600 [cells]
x 216 [dofs/cell/
var] )
2319+--------------------------------------+------------------+------------+------------------+
2323+--------------------------------------+------------------+------------+------------------+
2324| compute
errors | 1 | 0.009594s 16 | 0.009705s | 0.009819s 8 |
2325| compute
transport speed | 22 | 0.1366s 0 | 0.1367s | 0.1368s 18 |
2326| output | 1 | 1.233s 0 | 1.233s | 1.233s 32 |
2329+--------------------------------------+------------------+------------+------------------+
2337 <
img src=
"https://www.dealii.org/images/steps/developer/step-67.pressure_010.png" alt=
"" width=
"100%">
2340 <
img src=
"https://www.dealii.org/images/steps/developer/step-67.pressure_025.png" alt=
"" width=
"100%">
2345 <
img src=
"https://www.dealii.org/images/steps/developer/step-67.pressure_050.png" alt=
"" width=
"100%">
2348 <
img src=
"https://www.dealii.org/images/steps/developer/step-67.pressure_100.png" alt=
"" width=
"100%">
2358Number
of degrees
of freedom: 27.648.000 ( = 5 [vars]
x 25.600 [cells]
x 216 [dofs/cell/
var] )
2361+-------------------------------------------+------------------+------------+------------------+
2365+-------------------------------------------+------------------+------------+------------------+
2366| compute
errors | 1 | 0.007977s 10 | 0.008053s | 0.008161s 30 |
2367| compute
transport speed | 22 | 0.1228s 34 | 0.2227s | 0.3845s 0 |
2368| output | 1 | 1.255s 3 | 1.257s | 1.259s 27 |
2372+-------------------------------------------+------------------+------------+------------------+
2378<a name=
"step_76-Possibilitiesforextensions"></a><
h3>Possibilities
for extensions</
h3>
2382<a
href=
"https://github.com/hyperdeal/hyperdeal/blob/a9e67b4e625ff1dde2fed93ad91cdfacfaa3acdf/include/hyper.deal/operators/advection/advection_operation.h#L219-L569">
advection operator based on cell-
centric loops</a>
2418 [&](
const auto &
data,
auto &dst,
const auto &src,
const auto cell_range) {
2426 const auto boundary_id =
data.get_faces_by_cells_boundary_id(cell, face)[0];
2430 phi_p.reinit(cell, face);
2435 flags().
begin() +
data.n_active_entries_per_cell_batch(cell) == 1;
2478<a name=
"step_76-PlainProg"></a>
void submit_value(const value_type val_in, const unsigned int q_point)
Abstract base class for mapping classes.
void loop_cell_centric(void(CLASS::*cell_operation)(const MatrixFree &, OutVector &, const InVector &, const std::pair< unsigned int, unsigned int > &) const, const CLASS *owning_class, OutVector &dst, const InVector &src, const bool zero_dst_vector=false, const DataAccessOnFaces src_vector_face_access=DataAccessOnFaces::unspecified) const
void reinit(const MappingType &mapping, const DoFHandler< dim > &dof_handler, const AffineConstraints< number2 > &constraint, const QuadratureType &quad, const AdditionalData &additional_data=AdditionalData())
constexpr numbers::NumberTraits< Number >::real_type norm_square() const
std::enable_if_t< std::is_floating_point_v< T > &&std::is_floating_point_v< U > &&!std::is_same_v< T, U >, typename ProductType< std::complex< T >, std::complex< U > >::type > operator*(const std::complex< T > &left, const std::complex< U > &right)
#define DEAL_II_ALWAYS_INLINE
#define Assert(cond, exc)
#define AssertDimension(dim1, dim2)
#define AssertThrow(cond, exc)
void loop(IteratorType begin, std_cxx20::type_identity_t< IteratorType > end, DOFINFO &dinfo, INFOBOX &info, const std::function< void(std_cxx20::type_identity_t< DOFINFO > &, typename INFOBOX::CellInfo &)> &cell_worker, const std::function< void(std_cxx20::type_identity_t< DOFINFO > &, typename INFOBOX::CellInfo &)> &boundary_worker, const std::function< void(std_cxx20::type_identity_t< DOFINFO > &, std_cxx20::type_identity_t< DOFINFO > &, typename INFOBOX::CellInfo &, typename INFOBOX::CellInfo &)> &face_worker, AssemblerType &assembler, const LoopControl &lctrl=LoopControl())
@ update_values
Shape function values.
@ update_normal_vectors
Normal vectors.
@ update_JxW_values
Transformed quadrature weights.
@ update_gradients
Shape function gradients.
@ update_quadrature_points
Transformed quadrature points.
#define DEAL_II_NOT_IMPLEMENTED()
std::vector< index_type > data
DataComponentInterpretation
@ component_is_part_of_vector
void hyper_rectangle(Triangulation< dim, spacedim > &tria, const Point< dim > &p1, const Point< dim > &p2, const bool colorize=false)
void channel_with_cylinder(Triangulation< dim > &tria, const double shell_region_width=0.03, const unsigned int n_shells=2, const double skewness=2.0, const bool colorize=false)
@ matrix
Contents is actually a matrix.
@ general
No special properties.
constexpr types::blas_int one
double norm(const FEValuesBase< dim > &fe, const ArrayView< const std::vector< Tensor< 1, dim > > > &Du)
Point< spacedim > point(const gp_Pnt &p, const double tolerance=1e-10)
SymmetricTensor< 2, dim, Number > C(const Tensor< 2, dim, Number > &F)
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
@ LOW_STORAGE_RK_STAGE9_ORDER5
@ LOW_STORAGE_RK_STAGE3_ORDER3
@ LOW_STORAGE_RK_STAGE7_ORDER4
@ LOW_STORAGE_RK_STAGE5_ORDER4
VectorType::value_type * begin(VectorType &V)
T sum(const T &t, const MPI_Comm mpi_communicator)
unsigned int n_mpi_processes(const MPI_Comm mpi_communicator)
T max(const T &t, const MPI_Comm mpi_communicator)
T min(const T &t, const MPI_Comm mpi_communicator)
unsigned int this_mpi_process(const MPI_Comm mpi_communicator)
T reduce(const T &local_value, const MPI_Comm comm, const std::function< T(const T &, const T &)> &combiner, const unsigned int root_process=0)
std::string get_current_vectorization_level()
Number truncate_to_n_digits(const Number number, const unsigned int n_digits)
std::string int_to_string(const unsigned int value, const unsigned int digits=numbers::invalid_unsigned_int)
constexpr T pow(const T base, const int iexp)
void run(const Iterator &begin, const std_cxx20::type_identity_t< Iterator > &end, Worker worker, Copier copier, const ScratchData &sample_scratch_data, const CopyData &sample_copy_data, const unsigned int queue_length, const unsigned int chunk_size)
long double gamma(const unsigned int n)
void copy(const T *begin, const T *end, U *dest)
int(&) functions(const void *v1, const void *v2)
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
constexpr unsigned int invalid_unsigned_int
constexpr types::boundary_id internal_face_boundary_id
void transform(const InputIterator &begin_in, const InputIterator &end_in, OutputIterator out, const Function &function, const unsigned int grainsize)
::VectorizedArray< Number, width > exp(const ::VectorizedArray< Number, width > &)
::VectorizedArray< Number, width > min(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
::VectorizedArray< Number, width > max(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
::VectorizedArray< Number, width > sqrt(const ::VectorizedArray< Number, width > &)
::VectorizedArray< Number, width > pow(const ::VectorizedArray< Number, width > &, const Number p)
::VectorizedArray< Number, width > abs(const ::VectorizedArray< Number, width > &)
const ::parallel::distributed::Triangulation< dim, spacedim > * triangulation