177 * <a name=
"data.h-Dataandexactsolution"></a>
202 *
const unsigned int component = 0)
const override;
207 *
const unsigned int )
const
209 *
const double x = p[0];
210 *
const double y = p[1];
220 *
Assert(
false, ExcMessage(
"The RHS data for dim != 2 is not provided"));
233 *
const unsigned int component = 0)
const override;
238 *
const unsigned int )
const
240 *
const double x = p[0];
241 *
const double y = p[1];
248 *
Assert(
false, ExcMessage(
"The BC data for dim != 2 is not provided"));
260 *
virtual void vector_value (
const Point<dim> &p,
263 *
virtual void vector_gradient (
const Point<dim> &p,
273 *
ExcDimensionMismatch (
values.size(), dim+1));
275 *
const double x = p[0];
276 *
const double y = p[1];
286 *
Assert(
false, ExcMessage(
"The exact solution for dim != 2 is not provided"));
295 *
const double x = p[0];
296 *
const double y = p[1];
316 *
Assert(
false, ExcMessage(
"The exact solution's gradient for dim != 2 is not provided"));
328 *
virtual void value_list (
const std::vector<
Point<dim> > &points,
338 *
ExcDimensionMismatch (points.size(),
values.size()));
340 *
for (
unsigned int p=0; p<points.size(); ++p)
344 *
const double x = points[p][0];
345 *
const double y = points[p][1];
356 *
Assert(
false, ExcMessage(
"The inverse of permeability tensor for dim != 2 is not provided"));
366<a name=
"ann-mfmfe.cc"></a>
390 * <a name=
"mfmfe.cc-Includefiles"></a>
461 * <a name=
"mfmfe.cc-Definitionofmultipointfluxassemblydatastructures"></a>
486 *
size_t operator()(
const Point<dim> &p)
const
489 *
h1 = std::hash<double>()(p[0]);
496 *
h2 = std::hash<double>()(p[1]);
499 *
h2 = std::hash<double>()(p[1]);
500 *
h3 = std::hash<double>()(p[2]);
501 *
return (
h1 ^ (
h2 << 1)) ^
h3;
539 *
std::vector<types::global_dof_index> local_dof_indices;
583 *
const unsigned long num_cells;
589 *
std::vector<Tensor<1,dim> >
phi_u;
591 *
std::vector<double>
phi_p;
605 *
fe_face_values (fe,
609 *
num_cells(tria.n_active_cells()),
613 *
phi_u(fe.dofs_per_cell),
615 *
phi_p(fe.dofs_per_cell)
620 *
for (; face !=
endf; ++face)
629 *
fe_values (scratch_data.fe_values.get_fe(),
630 *
scratch_data.fe_values.get_quadrature(),
633 *
fe_face_values (scratch_data.fe_face_values.get_fe(),
634 *
scratch_data.fe_face_values.get_quadrature(),
638 *
num_cells(scratch_data.num_cells),
642 *
phi_u(scratch_data.phi_u),
644 *
phi_p(scratch_data.phi_p)
683 * <a name=
"mfmfe.cc-ThecodeMultipointMixedDarcyProblemcodeclasstemplate"></a>
701 *
void run (
const unsigned int refine);
722 *
void output_results (
const unsigned int cycle,
const unsigned int refine);
724 *
const unsigned int degree;
756 * <a name=
"mfmfe.cc-Constructoranddestructorcodereset_data_structurescode"></a>
791 *
dof_handler.
clear();
817 * <a name=
"mfmfe.cc-Cellwiseassemblyandcreationofthelocalnodalbaseddatastructures"></a>
861 *
copy_data.cell_mat.
clear();
862 *
copy_data.cell_vec.
clear();
863 *
copy_data.local_vel_indices.
clear();
864 *
copy_data.local_pres_indices.
clear();
866 *
const unsigned int dofs_per_cell = fe.dofs_per_cell;
867 *
const unsigned int n_q_points = scratch_data.fe_values.get_quadrature().size();
868 *
const unsigned int n_face_q_points = scratch_data.fe_face_values.get_quadrature().size();
870 *
copy_data.local_dof_indices.resize(dofs_per_cell);
871 *
cell->get_dof_indices (copy_data.local_dof_indices);
873 *
scratch_data.fe_values.reinit (cell);
879 *
k_inverse.value_list (scratch_data.fe_values.get_quadrature_points(), scratch_data.k_inverse_values);
880 *
rhs.value_list(scratch_data.fe_values.get_quadrature_points(), scratch_data.rhs_values);
886 *
std::unordered_map<unsigned int, std::unordered_map<unsigned int, double>>
div_map;
896 *
for (
unsigned int q=0;
q<n_q_points; ++
q)
898 *
const Point<dim> p = scratch_data.fe_values.quadrature_point(
q);
900 *
for (
unsigned int k=0;
k<dofs_per_cell; ++
k)
902 *
scratch_data.phi_u[
k] = scratch_data.fe_values[
velocity].value(
k,
q);
903 *
scratch_data.div_phi_u[
k] = scratch_data.fe_values[
velocity].divergence (
k,
q);
904 *
scratch_data.phi_p[
k] = scratch_data.fe_values[
pressure].value (
k,
q);
907 *
for (
unsigned int i=0; i<dofs_per_cell; ++i)
909 *
for (
unsigned int j=
n_vel;
j<dofs_per_cell; ++
j)
911 *
double div_term = (- scratch_data.div_phi_u[i] * scratch_data.phi_p[
j]
912 *
- scratch_data.phi_p[i] * scratch_data.div_phi_u[
j]) * scratch_data.fe_values.JxW(
q);
918 *
double source_term = -scratch_data.phi_p[i] * scratch_data.rhs_values[
q] * scratch_data.fe_values.JxW(
q);
921 *
copy_data.cell_vec[p][copy_data.local_dof_indices[i]] +=
source_term;
934 *
for (
unsigned int q=0;
q<n_q_points; ++
q)
937 *
const Point<dim> p = scratch_data.fe_values.quadrature_point(
q);
939 *
for (
unsigned int k=0;
k<dofs_per_cell; ++
k)
941 *
scratch_data.phi_u[
k] = scratch_data.fe_values[
velocity].value(
k,
q);
942 *
scratch_data.div_phi_u[
k] = scratch_data.fe_values[
velocity].divergence (
k,
q);
943 *
scratch_data.phi_p[
k] = scratch_data.fe_values[
pressure].value (
k,
q);
946 *
for (
unsigned int i=0; i<dofs_per_cell; ++i)
947 *
for (
unsigned int j=i;
j<dofs_per_cell; ++
j)
949 *
double mass_term = scratch_data.phi_u[i]
950 *
* scratch_data.k_inverse_values[
q]
951 *
* scratch_data.phi_u[
j]
952 *
* scratch_data.fe_values.JxW(
q);
956 *
copy_data.cell_mat[p][std::make_pair(copy_data.local_dof_indices[i], copy_data.local_dof_indices[
j])] +=
959 *
copy_data.local_vel_indices[p].insert(copy_data.local_dof_indices[
j]);
968 *
copy_data.local_dof_indices[el.
first])] += el.
second;
969 *
copy_data.local_pres_indices[p].insert(copy_data.local_dof_indices[el.first]);
978 *
std::map<types::global_dof_index,double>
pres_bc;
982 *
if (cell->at_boundary(
face_no))
984 *
scratch_data.fe_face_values.reinit (cell,
face_no);
985 *
pressure_bc.value_list(scratch_data.fe_face_values.get_quadrature_points(), scratch_data.pres_bc_values);
988 *
for (
unsigned int i = 0; i < dofs_per_cell; ++i)
990 *
double tmp = -(scratch_data.fe_face_values[
velocity].value(i,
q) *
991 *
scratch_data.fe_face_values.normal_vector(
q) *
992 *
scratch_data.pres_bc_values[
q] *
993 *
scratch_data.fe_face_values.JxW(
q));
996 *
pres_bc[copy_data.local_dof_indices[i]] += tmp;
1005 *
for (
auto m : copy_data.
cell_vec)
1006 *
for (unsigned
int i=0; i<dofs_per_cell; ++i)
1008 *
copy_data.cell_vec[m.first][copy_data.local_dof_indices[i]] +=
pres_bc[copy_data.local_dof_indices[i]];
1022 *
template <
int dim>
1027 *
dof_handler.distribute_dofs(fe);
1029 *
const std::vector<types::global_dof_index> dofs_per_component
1035 *
n_v = dofs_per_component[0];
1036 *
n_p = dofs_per_component[dim];
1041 *
dof_handler.end(),
1052 * <a name=
"mfmfe.cc-Makingthesparsitypattern"></a>
1063 *
template <
int dim>
1069 *
std::set<types::global_dof_index>::iterator
pi_it,
pj_it;
1070 *
unsigned int i,
j;
1090 * <a name=
"mfmfe.cc-Thelocaleliminationprocedure"></a>
1103 *
template <
int dim>
1113 *
copy_data.pressure_matrix.reinit(
n_edges,n_cells);
1115 *
copy_data.velocity_rhs.reinit(
n_edges);
1116 *
scratch_data.pressure_rhs.reinit(n_cells);
1119 *
std::set<types::global_dof_index>::iterator
vi_it,
vj_it,
p_it;
1140 *
copy_data.velocity_rhs(i) +=
node_rhs.at((*n_it).first)[*
vi_it];
1146 *
scratch_data.pressure_rhs(i) +=
node_rhs.at((*n_it).first)[*
p_it];
1151 *
scratch_data.tmp_rhs1.reinit(
n_edges);
1152 *
scratch_data.tmp_rhs2.reinit(
n_edges);
1153 *
scratch_data.tmp_rhs3.reinit(n_cells);
1155 *
copy_data.Ainverse.invert(scratch_data.velocity_matrix);
1156 *
copy_data.node_pres_matrix.reinit(n_cells, n_cells);
1157 *
copy_data.node_pres_rhs = scratch_data.pressure_rhs;
1159 *
copy_data.node_pres_matrix = 0;
1160 *
copy_data.node_pres_matrix.triple_product(copy_data.Ainverse,
1161 *
copy_data.pressure_matrix,
1162 *
copy_data.pressure_matrix,
true,
false);
1164 *
copy_data.Ainverse.vmult(scratch_data.tmp_rhs1, copy_data.velocity_rhs,
false);
1165 *
copy_data.pressure_matrix.Tvmult(scratch_data.tmp_rhs3, scratch_data.tmp_rhs1,
false);
1166 *
copy_data.node_pres_rhs *= -1.0;
1167 *
copy_data.node_pres_rhs += scratch_data.tmp_rhs3;
1169 *
copy_data.p = (*n_it).first;
1175 *
Each node's pressure system is then distributed to a global pressure
1176 * system, using the indices we computed in the previous stages.
1179 * template <int dim>
1180 * void MultipointMixedDarcyProblem<dim>::
1181 * copy_node_to_system(const DataStructures::NodeEliminationCopyData<dim> ©_data)
1183 * A_inverse[copy_data.p] = copy_data.Ainverse;
1184 * pressure_matrix[copy_data.p] = copy_data.pressure_matrix;
1185 * velocity_rhs[copy_data.p] = copy_data.velocity_rhs;
1188 * std::set<types::global_dof_index>::iterator pi_it, pj_it;
1190 * for (pi_it = pressure_indices[copy_data.p].begin(), i = 0;
1191 * pi_it != pressure_indices[copy_data.p].end();
1195 * for (pj_it = pressure_indices[copy_data.p].begin(), j = 0;
1196 * pj_it != pressure_indices[copy_data.p].end();
1198 * pres_system_matrix.add(*pi_it - n_v, *pj_it - n_v, copy_data.node_pres_matrix(i, j));
1200 * pres_rhs(*pi_it - n_v) += copy_data.node_pres_rhs(i);
1208 * The @ref WorkStream mechanism is again used for the assembly
1209 * of the global system for the pressure variable, where the
1210 * previous functions are used to perform local computations.
1213 * template <int dim>
1214 * void MultipointMixedDarcyProblem<dim>::pressure_assembly()
1216 * TimerOutput::Scope t(computing_timer, "Pressure matrix assembly");
1218 * QGaussLobatto<dim> quad(degree+1);
1219 * QGauss<dim-1> face_quad(degree);
1221 * pres_rhs.reinit(n_p);
1223 * WorkStream::run(node_matrix.begin(),
1224 * node_matrix.end(),
1226 * &MultipointMixedDarcyProblem::nodal_elimination,
1227 * &MultipointMixedDarcyProblem::copy_node_to_system,
1228 * DataStructures::VertexEliminationScratchData(),
1229 * DataStructures::NodeEliminationCopyData<dim>());
1237 * <a name="mfmfe.cc-Velocitysolutionrecovery"></a>
1238 * <h4>Velocity solution recovery</h4>
1242 * After solving for the pressure variable, we want to follow
1243 * the above procedure backwards, in order to obtain the
1244 * velocity solution (again, this is similar in nature to the
1245 * Schur complement approach, see @ref step_20 "step-20", but here it is done
1246 * locally at each node). We have almost everything computed and
1247 * stored already, including inverses of local mass matrices,
1248 * so the following is a relatively straightforward implementation.
1251 * template <int dim>
1252 * void MultipointMixedDarcyProblem<dim>::
1253 * velocity_assembly (const typename DataStructures::PointToMatrixMap<dim>::iterator &n_it,
1254 * DataStructures::VertexEliminationScratchData &scratch_data,
1255 * DataStructures::NodeEliminationCopyData<dim> ©_data)
1257 * unsigned int n_edges = velocity_indices.at((*n_it).first).size();
1258 * unsigned int n_cells = pressure_indices.at((*n_it).first).size();
1260 * scratch_data.tmp_rhs1.reinit(n_edges);
1261 * scratch_data.tmp_rhs2.reinit(n_edges);
1262 * scratch_data.tmp_rhs3.reinit(n_cells);
1263 * scratch_data.local_pressure_solution.reinit(n_cells);
1265 * copy_data.vertex_vel_solution.reinit(n_edges);
1267 * std::set<types::global_dof_index>::iterator p_it;
1270 * for (p_it = pressure_indices[(*n_it).first].begin(), i = 0;
1271 * p_it != pressure_indices[(*n_it).first].end();
1273 * scratch_data.local_pressure_solution(i) = pres_solution(*p_it - n_v);
1275 * pressure_matrix[(*n_it).first].vmult(scratch_data.tmp_rhs2, scratch_data.local_pressure_solution, false);
1276 * scratch_data.tmp_rhs2 *= -1.0;
1277 * scratch_data.tmp_rhs2+=velocity_rhs[(*n_it).first];
1278 * A_inverse[(*n_it).first].vmult(copy_data.vertex_vel_solution, scratch_data.tmp_rhs2, false);
1280 * copy_data.p = (*n_it).first;
1286 * Copy nodal velocities to a global solution vector by using
1287 * local computations and indices from early stages.
1290 * template <int dim>
1291 * void MultipointMixedDarcyProblem<dim>::
1292 * copy_node_velocity_to_global(const DataStructures::NodeEliminationCopyData<dim> ©_data)
1294 * std::set<types::global_dof_index>::iterator vi_it;
1297 * for (vi_it = velocity_indices[copy_data.p].begin(), i = 0;
1298 * vi_it != velocity_indices[copy_data.p].end();
1300 * vel_solution(*vi_it) += copy_data.vertex_vel_solution(i);
1306 * Use @ref WorkStream to run everything concurrently.
1309 * template <int dim>
1310 * void MultipointMixedDarcyProblem<dim>::velocity_recovery()
1312 * TimerOutput::Scope t(computing_timer, "Velocity solution recovery");
1314 * QGaussLobatto<dim> quad(degree+1);
1315 * QGauss<dim-1> face_quad(degree);
1317 * vel_solution.reinit(n_v);
1319 * WorkStream::run(node_matrix.begin(),
1320 * node_matrix.end(),
1322 * &MultipointMixedDarcyProblem::velocity_assembly,
1323 * &MultipointMixedDarcyProblem::copy_node_velocity_to_global,
1324 * DataStructures::VertexEliminationScratchData(),
1325 * DataStructures::NodeEliminationCopyData<dim>());
1327 * solution.reinit(2);
1328 * solution.block(0) = vel_solution;
1329 * solution.block(1) = pres_solution;
1330 * solution.collect_sizes();
1338 * <a name="mfmfe.cc-Pressuresystemsolver"></a>
1339 * <h4>Pressure system solver</h4>
1343 * The solver part is trivial. We use the CG solver with no
1344 * preconditioner for simplicity.
1347 * template <int dim>
1348 * void MultipointMixedDarcyProblem<dim>::solve_pressure()
1350 * TimerOutput::Scope t(computing_timer, "Pressure CG solve");
1352 * pres_solution.reinit(n_p);
1354 * SolverControl solver_control (static_cast<int>(2.0*n_p), 1e-10);
1355 * SolverCG<> solver (solver_control);
1357 * PreconditionIdentity identity;
1358 * solver.solve(pres_system_matrix, pres_solution, pres_rhs, identity);
1366 * <a name="mfmfe.cc-Postprocessing"></a>
1367 * <h3>Postprocessing</h3>
1371 * We have two postprocessing steps here, first one computes the
1372 * errors in order to populate the convergence tables. The other
1373 * one takes care of the output of the solutions in <code>.vtk</code>
1379 * <a name="mfmfe.cc-Computeerrors"></a>
1380 * <h4>Compute errors</h4>
1384 * The implementation of this function is almost identical to @ref step_20 "step-20".
1385 * We use @ref ComponentSelectFunction as masks to use the right
1386 * solution component (velocity or pressure) and `integrate_difference()`
1387 * to compute the errors. Since we also want to compute Hdiv seminorm of the
1388 * velocity error, one must provide gradients in the <code>ExactSolution</code>
1389 * class implementation to avoid exceptions. The only noteworthy thing here
1390 * is that we again use lower order quadrature rule instead of projecting the
1391 * solution to an appropriate space in order to show superconvergence, which is
1392 * mathematically justified.
1395 * template <int dim>
1396 * void MultipointMixedDarcyProblem<dim>::compute_errors(const unsigned cycle)
1398 * TimerOutput::Scope t(computing_timer, "Compute errors");
1400 * const ComponentSelectFunction<dim> pressure_mask(dim, dim+1);
1401 * const ComponentSelectFunction<dim> velocity_mask(std::make_pair(0, dim), dim+1);
1403 * ExactSolution<dim> exact_solution;
1405 * Vector<double> cellwise_errors (triangulation.n_active_cells());
1407 * QTrapezoid<1> q_trapez;
1408 * QIterated<dim> quadrature(q_trapez,degree+2);
1409 * QGauss<dim> quadrature_super(degree);
1411 * VectorTools::integrate_difference (dof_handler, solution, exact_solution,
1412 * cellwise_errors, quadrature,
1413 * VectorTools::L2_norm,
1415 * const double p_l2_error = cellwise_errors.l2_norm();
1417 * VectorTools::integrate_difference (dof_handler, solution, exact_solution,
1418 * cellwise_errors, quadrature_super,
1419 * VectorTools::L2_norm,
1421 * const double p_l2_mid_error = cellwise_errors.l2_norm();
1423 * VectorTools::integrate_difference (dof_handler, solution, exact_solution,
1424 * cellwise_errors, quadrature,
1425 * VectorTools::L2_norm,
1427 * const double u_l2_error = cellwise_errors.l2_norm();
1429 * VectorTools::integrate_difference (dof_handler, solution, exact_solution,
1430 * cellwise_errors, quadrature,
1431 * VectorTools::Hdiv_seminorm,
1433 * const double u_hd_error = cellwise_errors.l2_norm();
1435 * const unsigned int n_active_cells=triangulation.n_active_cells();
1436 * const unsigned int n_dofs=dof_handler.n_dofs();
1438 * convergence_table.add_value("cycle", cycle);
1439 * convergence_table.add_value("cells", n_active_cells);
1440 * convergence_table.add_value("dofs", n_dofs);
1441 * convergence_table.add_value("Velocity,L2", u_l2_error);
1442 * convergence_table.add_value("Velocity,Hdiv", u_hd_error);
1443 * convergence_table.add_value("Pressure,L2", p_l2_error);
1444 * convergence_table.add_value("Pressure,L2-nodal", p_l2_mid_error);
1452 * <a name="mfmfe.cc-Outputresults"></a>
1453 * <h4>Output results</h4>
1457 * This function also follows the same idea as in @ref step_20 "step-20" tutorial
1458 * program. The only modification to it is the part involving
1459 * a convergence table.
1462 * template <int dim>
1463 * void MultipointMixedDarcyProblem<dim>::output_results(const unsigned int cycle, const unsigned int refine)
1465 * TimerOutput::Scope t(computing_timer, "Output results");
1467 * std::vector<std::string> solution_names(dim, "u");
1468 * solution_names.push_back ("p");
1469 * std::vector<DataComponentInterpretation::DataComponentInterpretation>
1470 * interpretation (dim, DataComponentInterpretation::component_is_part_of_vector);
1471 * interpretation.push_back (DataComponentInterpretation::component_is_scalar);
1473 * DataOut<dim> data_out;
1474 * data_out.add_data_vector (dof_handler, solution, solution_names, interpretation);
1475 * data_out.build_patches ();
1477 * std::ofstream output ("solution" + std::to_string(dim) + "d-" + std::to_string(cycle) + ".vtk");
1478 * data_out.write_vtk (output);
1480 * convergence_table.set_precision("Velocity,L2", 3);
1481 * convergence_table.set_precision("Velocity,Hdiv", 3);
1482 * convergence_table.set_precision("Pressure,L2", 3);
1483 * convergence_table.set_precision("Pressure,L2-nodal", 3);
1484 * convergence_table.set_scientific("Velocity,L2", true);
1485 * convergence_table.set_scientific("Velocity,Hdiv", true);
1486 * convergence_table.set_scientific("Pressure,L2", true);
1487 * convergence_table.set_scientific("Pressure,L2-nodal", true);
1488 * convergence_table.set_tex_caption("cells", "\\# cells");
1489 * convergence_table.set_tex_caption("dofs", "\\# dofs");
1490 * convergence_table.set_tex_caption("Velocity,L2", " \\|\\u - \\u_h\\|_{L^2} ");
1491 * convergence_table.set_tex_caption("Velocity,Hdiv", " \\|\\nabla\\cdot(\\u - \\u_h)\\|_{L^2} ");
1492 * convergence_table.set_tex_caption("Pressure,L2", " \\|p - p_h\\|_{L^2} ");
1493 * convergence_table.set_tex_caption("Pressure,L2-nodal", " \\|Qp - p_h\\|_{L^2} ");
1494 * convergence_table.set_tex_format("cells", "r");
1495 * convergence_table.set_tex_format("dofs", "r");
1497 * convergence_table.evaluate_convergence_rates("Velocity,L2", ConvergenceTable::reduction_rate_log2);
1498 * convergence_table.evaluate_convergence_rates("Velocity,Hdiv", ConvergenceTable::reduction_rate_log2);
1499 * convergence_table.evaluate_convergence_rates("Pressure,L2", ConvergenceTable::reduction_rate_log2);
1500 * convergence_table.evaluate_convergence_rates("Pressure,L2-nodal", ConvergenceTable::reduction_rate_log2);
1502 * std::ofstream error_table_file("error" + std::to_string(dim) + "d.tex");
1504 * if (cycle == refine-1)
1506 * convergence_table.write_text(std::cout);
1507 * convergence_table.write_tex(error_table_file);
1516 * <a name="mfmfe.cc-Runfunction"></a>
1517 * <h3>Run function</h3>
1521 * The driver method <code>run()</code>
1522 * takes care of mesh generation and arranging calls to member methods in
1523 * the right way. It also resets data structures and clear triangulation and
1524 * DOF handler as we run the method on a sequence of refinements in order
1525 * to record convergence rates.
1528 * template <int dim>
1529 * void MultipointMixedDarcyProblem<dim>::run(const unsigned int refine)
1531 * Assert(refine > 0, ExcMessage("Must at least have 1 refinement cycle!"));
1533 * dof_handler.clear();
1534 * triangulation.clear();
1535 * convergence_table.clear();
1537 * for (unsigned int cycle=0; cycle<refine; ++cycle)
1543 * We first generate the hyper cube and refine it twice
1544 * so that we could distort the grid slightly and
1575 * <a name=
"mfmfe.cc-Thecodemaincodefunction"></a>
1589 *
using namespace dealii;
1590 *
using namespace MFMFE;
1597 *
catch (std::exception &exc)
1599 *
std::cerr << std::endl << std::endl
1600 *
<<
"----------------------------------------------------"
1602 *
std::cerr <<
"Exception on processing: " << std::endl
1603 *
<< exc.what() << std::endl
1604 *
<<
"Aborting!" << std::endl
1605 *
<<
"----------------------------------------------------"
1612 *
std::cerr << std::endl << std::endl
1613 *
<<
"----------------------------------------------------"
1615 *
std::cerr <<
"Unknown exception!" << std::endl
1616 *
<<
"Aborting!" << std::endl
1617 *
<<
"----------------------------------------------------"
static void set_thread_limit(const unsigned int max_threads=numbers::invalid_unsigned_int)
std::conditional_t< rank_==1, std::array< Number, dim >, std::array< Tensor< rank_ - 1, dim, Number >, dim > > values
static ::ExceptionBase & ExcNotImplemented()
#define Assert(cond, exc)
typename ActiveSelector::active_cell_iterator active_cell_iterator
@ 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.
std::vector< index_type > data
void component_wise(DoFHandler< dim, spacedim > &dof_handler, const std::vector< unsigned int > &target_component=std::vector< unsigned int >())
void hyper_cube(Triangulation< dim, spacedim > &tria, const double left=0., const double right=1., const bool colorize=false)
@ matrix
Contents is actually a matrix.
constexpr types::blas_int zero
constexpr types::blas_int one
SymmetricTensor< 2, dim, Number > C(const Tensor< 2, dim, Number > &F)
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
VectorType::value_type * begin(VectorType &V)
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)
void run(const std::vector< std::vector< Iterator > > &colored_iterators, Worker worker, Copier copier, const ScratchData &sample_scratch_data, const CopyData &sample_copy_data, const unsigned int queue_length=2 *MultithreadInfo::n_threads(), const unsigned int chunk_size=8)
unsigned int n_cells(const internal::TriangulationImplementation::NumberCache< 1 > &c)
void copy(const T *begin, const T *end, U *dest)
int(&) functions(const void *v1, const void *v2)
void assemble(const MeshWorker::DoFInfoBox< dim, DOFINFO > &dinfo, A *assembler)
::VectorizedArray< Number, width > cos(const ::VectorizedArray< Number, width > &)
::VectorizedArray< Number, width > sin(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