Reference documentation for deal.II version 9.5.0
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
data_out.cc
Go to the documentation of this file.
1// ---------------------------------------------------------------------
2//
3// Copyright (C) 1999 - 2022 by the deal.II authors
4//
5// This file is part of the deal.II library.
6//
7// The deal.II library is free software; you can use it, redistribute
8// it, and/or modify it under the terms of the GNU Lesser General
9// Public License as published by the Free Software Foundation; either
10// version 2.1 of the License, or (at your option) any later version.
11// The full text of the license can be found in the file LICENSE.md at
12// the top level directory of deal.II.
13//
14// ---------------------------------------------------------------------
15
16#include <deal.II/base/work_stream.h>
17
18#include <deal.II/dofs/dof_accessor.h>
19#include <deal.II/dofs/dof_handler.h>
20
21#include <deal.II/fe/fe.h>
22#include <deal.II/fe/fe_dgq.h>
23#include <deal.II/fe/fe_values.h>
24#include <deal.II/fe/mapping.h>
25
26#include <deal.II/grid/tria.h>
27#include <deal.II/grid/tria_iterator.h>
28
29#include <deal.II/hp/fe_values.h>
30
31#include <deal.II/numerics/data_out.h>
32
33#include <sstream>
34
35DEAL_II_NAMESPACE_OPEN
36
37
38namespace internal
39{
40 namespace DataOutImplementation
41 {
42 template <int dim, int spacedim>
43 ParallelData<dim, spacedim>::ParallelData(
44 const unsigned int n_datasets,
45 const unsigned int n_subdivisions,
46 const std::vector<unsigned int> &n_postprocessor_outputs,
47 const ::hp::MappingCollection<dim, spacedim> &mapping,
48 const std::vector<
49 std::shared_ptr<::hp::FECollection<dim, spacedim>>>
50 & finite_elements,
51 const UpdateFlags update_flags,
52 const std::vector<std::vector<unsigned int>> &cell_to_patch_index_map)
53 : ParallelDataBase<dim, spacedim>(n_datasets,
54 n_subdivisions,
55 n_postprocessor_outputs,
56 mapping,
57 finite_elements,
58 update_flags,
59 false)
60 , cell_to_patch_index_map(&cell_to_patch_index_map)
61 {}
62 } // namespace DataOutImplementation
63} // namespace internal
64
65
66
67template <int dim, int spacedim>
68DataOut<dim, spacedim>::DataOut()
69{
70 set_cell_selection(
71 [this](const Triangulation<dim, spacedim> &) {
72 typename Triangulation<dim, spacedim>::active_cell_iterator cell =
73 this->triangulation->begin_active();
74
75 // skip cells if the current one has no children (is active) and is a
76 // ghost or artificial cell
77 while ((cell != this->triangulation->end()) && !cell->is_locally_owned())
78 ++cell;
79 return cell;
80 },
81 [this](const Triangulation<dim, spacedim> &,
82 const cell_iterator &old_cell) {
83 typename Triangulation<dim, spacedim>::active_cell_iterator cell =
84 old_cell;
85 ++cell;
86 while ((cell != this->triangulation->end()) && !cell->is_locally_owned())
87 ++cell;
88 return cell;
89 });
90}
91
92
93
94template <int dim, int spacedim>
95void
96DataOut<dim, spacedim>::build_one_patch(
97 const std::pair<cell_iterator, unsigned int> * cell_and_index,
98 internal::DataOutImplementation::ParallelData<dim, spacedim> &scratch_data,
99 const unsigned int n_subdivisions,
100 const CurvedCellRegion curved_cell_region)
101{
102 // first create the output object that we will write into
103
104 ::DataOutBase::Patch<dim, spacedim> patch;
105 patch.n_subdivisions = n_subdivisions;
106 patch.reference_cell = cell_and_index->first->reference_cell();
107
108 // initialize FEValues
109 scratch_data.reinit_all_fe_values(this->dof_data, cell_and_index->first);
110
111 const FEValuesBase<dim, spacedim> &fe_patch_values =
112 scratch_data.get_present_fe_values(0);
113
114 const auto vertices =
115 fe_patch_values.get_mapping().get_vertices(cell_and_index->first);
116 std::copy(vertices.begin(), vertices.end(), std::begin(patch.vertices));
117
118 const unsigned int n_q_points = fe_patch_values.n_quadrature_points;
119
120 scratch_data.patch_values_scalar.solution_values.resize(n_q_points);
121 scratch_data.patch_values_scalar.solution_gradients.resize(n_q_points);
122 scratch_data.patch_values_scalar.solution_hessians.resize(n_q_points);
123 scratch_data.patch_values_system.solution_values.resize(n_q_points);
124 scratch_data.patch_values_system.solution_gradients.resize(n_q_points);
125 scratch_data.patch_values_system.solution_hessians.resize(n_q_points);
126
127 for (unsigned int dataset = 0;
128 dataset < scratch_data.postprocessed_values.size();
129 ++dataset)
130 if (scratch_data.postprocessed_values[dataset].size() != 0)
131 scratch_data.postprocessed_values[dataset].resize(n_q_points);
132
133 // First fill the geometric information for the patch: Where are the
134 // nodes in question located.
135 //
136 // Depending on the requested output of curved cells, if necessary
137 // append the quadrature points to the last rows of the patch.data
138 // member. This is the case if we want to produce curved cells at the
139 // boundary and this cell actually is at the boundary, or else if we
140 // want to produce curved cells everywhere
141 //
142 // note: a cell is *always* at the boundary if dim<spacedim
143 if (curved_cell_region == curved_inner_cells ||
144 (curved_cell_region == curved_boundary &&
145 (cell_and_index->first->at_boundary() || (dim != spacedim))) ||
146 (cell_and_index->first->reference_cell() !=
147 ReferenceCells::get_hypercube<dim>()))
148 {
149 Assert(patch.space_dim == spacedim, ExcInternalError());
150
151 // set the flag indicating that for this cell the points are
152 // explicitly given
153 patch.points_are_available = true;
154
155 // then size the patch.data member in order to have enough memory for
156 // the quadrature points as well, and copy the quadrature points there
157 const std::vector<Point<spacedim>> &q_points =
158 fe_patch_values.get_quadrature_points();
159
160 patch.data.reinit(scratch_data.n_datasets + spacedim, n_q_points);
161 for (unsigned int i = 0; i < spacedim; ++i)
162 for (unsigned int q = 0; q < n_q_points; ++q)
163 patch.data(patch.data.size(0) - spacedim + i, q) = q_points[q][i];
164 }
165 else
166 {
167 patch.data.reinit(scratch_data.n_datasets, n_q_points);
168 patch.points_are_available = false;
169 }
170
171
172 // Next fill the information we get from DoF data
173 if (scratch_data.n_datasets > 0)
174 {
175 // counter for data records
176 unsigned int offset = 0;
177
178 // first fill dof_data
179 unsigned int dataset_number = 0;
180 for (const auto &dataset : this->dof_data)
181 {
182 const FEValuesBase<dim, spacedim> &this_fe_patch_values =
183 scratch_data.get_present_fe_values(dataset_number);
184 const unsigned int n_components =
185 this_fe_patch_values.get_fe().n_components();
186
187 const DataPostprocessor<spacedim> *postprocessor =
188 dataset->postprocessor;
189
190 if (postprocessor != nullptr)
191 {
192 // We have to postprocess the data, so determine, which fields
193 // have to be updated
194 const UpdateFlags update_flags =
195 postprocessor->get_needed_update_flags();
196
197 if ((n_components == 1) &&
198 (dataset->is_complex_valued() == false))
199 {
200 // At each point there is only one component of value,
201 // gradient etc. Based on the 'if' statement above, we
202 // know that the solution is scalar and real-valued, so
203 // we do not need to worry about getting any imaginary
204 // components to the postprocessor, and we can safely
205 // call the function that evaluates a scalar field
206 if (update_flags & update_values)
207 dataset->get_function_values(
208 this_fe_patch_values,
209 internal::DataOutImplementation::ComponentExtractor::
210 real_part,
211 scratch_data.patch_values_scalar.solution_values);
212
213 if (update_flags & update_gradients)
214 dataset->get_function_gradients(
215 this_fe_patch_values,
216 internal::DataOutImplementation::ComponentExtractor::
217 real_part,
218 scratch_data.patch_values_scalar.solution_gradients);
219
220 if (update_flags & update_hessians)
221 dataset->get_function_hessians(
222 this_fe_patch_values,
223 internal::DataOutImplementation::ComponentExtractor::
224 real_part,
225 scratch_data.patch_values_scalar.solution_hessians);
226
227 // Also fill some of the other fields postprocessors may
228 // want to access.
229 if (update_flags & update_quadrature_points)
230 scratch_data.patch_values_scalar.evaluation_points =
231 this_fe_patch_values.get_quadrature_points();
232
233 const typename DoFHandler<dim, spacedim>::cell_iterator
234 dh_cell(&cell_and_index->first->get_triangulation(),
235 cell_and_index->first->level(),
236 cell_and_index->first->index(),
237 dataset->dof_handler);
238 scratch_data.patch_values_scalar.template set_cell<dim>(
239 dh_cell);
240
241 // Finally call the postprocessor's function that
242 // deals with scalar inputs.
243 postprocessor->evaluate_scalar_field(
244 scratch_data.patch_values_scalar,
245 scratch_data.postprocessed_values[dataset_number]);
246 }
247 else
248 {
249 // At each point we now have to evaluate a vector valued
250 // function and its derivatives. It may be that the solution
251 // is scalar and complex-valued, but we treat this as a vector
252 // field with two components.
253
254 // At this point, we need to ask how we fill the fields that
255 // we want to pass on to the postprocessor. If the field in
256 // question is real-valued, we'll just extract the (only)
257 // real component from the solution fields
258 if (dataset->is_complex_valued() == false)
259 {
260 scratch_data.resize_system_vectors(n_components);
261
262 if (update_flags & update_values)
263 dataset->get_function_values(
264 this_fe_patch_values,
265 internal::DataOutImplementation::ComponentExtractor::
266 real_part,
267 scratch_data.patch_values_system.solution_values);
268
269 if (update_flags & update_gradients)
270 dataset->get_function_gradients(
271 this_fe_patch_values,
272 internal::DataOutImplementation::ComponentExtractor::
273 real_part,
274 scratch_data.patch_values_system.solution_gradients);
275
276 if (update_flags & update_hessians)
277 dataset->get_function_hessians(
278 this_fe_patch_values,
279 internal::DataOutImplementation::ComponentExtractor::
280 real_part,
281 scratch_data.patch_values_system.solution_hessians);
282 }
283 else
284 {
285 // The solution is complex-valued. Let's cover the scalar
286 // case first (i.e., one scalar but complex-valued field,
287 // which we will have to split into its real and imaginar
288 // parts).
289 if (n_components == 1)
290 {
291 scratch_data.resize_system_vectors(2);
292
293 // First get the real component of the scalar solution
294 // and copy the data into the
295 // scratch_data.patch_values_system output fields
296 if (update_flags & update_values)
297 {
298 dataset->get_function_values(
299 this_fe_patch_values,
300 internal::DataOutImplementation::
301 ComponentExtractor::real_part,
302 scratch_data.patch_values_scalar
303 .solution_values);
304
305 for (unsigned int i = 0;
306 i < scratch_data.patch_values_scalar
307 .solution_values.size();
308 ++i)
309 {
310 AssertDimension(
311 scratch_data.patch_values_system
312 .solution_values[i]
313 .size(),
314 2);
315 scratch_data.patch_values_system
316 .solution_values[i][0] =
317 scratch_data.patch_values_scalar
318 .solution_values[i];
319 }
320 }
321
322 if (update_flags & update_gradients)
323 {
324 dataset->get_function_gradients(
325 this_fe_patch_values,
326 internal::DataOutImplementation::
327 ComponentExtractor::real_part,
328 scratch_data.patch_values_scalar
329 .solution_gradients);
330
331 for (unsigned int i = 0;
332 i < scratch_data.patch_values_scalar
333 .solution_gradients.size();
334 ++i)
335 {
336 AssertDimension(
337 scratch_data.patch_values_system
338 .solution_values[i]
339 .size(),
340 2);
341 scratch_data.patch_values_system
342 .solution_gradients[i][0] =
343 scratch_data.patch_values_scalar
344 .solution_gradients[i];
345 }
346 }
347
348 if (update_flags & update_hessians)
349 {
350 dataset->get_function_hessians(
351 this_fe_patch_values,
352 internal::DataOutImplementation::
353 ComponentExtractor::real_part,
354 scratch_data.patch_values_scalar
355 .solution_hessians);
356
357 for (unsigned int i = 0;
358 i < scratch_data.patch_values_scalar
359 .solution_hessians.size();
360 ++i)
361 {
362 AssertDimension(
363 scratch_data.patch_values_system
364 .solution_hessians[i]
365 .size(),
366 2);
367 scratch_data.patch_values_system
368 .solution_hessians[i][0] =
369 scratch_data.patch_values_scalar
370 .solution_hessians[i];
371 }
372 }
373
374 // Now we also have to get the imaginary
375 // component of the scalar solution
376 // and copy the data into the
377 // scratch_data.patch_values_system output fields
378 // that follow the real one
379 if (update_flags & update_values)
380 {
381 dataset->get_function_values(
382 this_fe_patch_values,
383 internal::DataOutImplementation::
384 ComponentExtractor::imaginary_part,
385 scratch_data.patch_values_scalar
386 .solution_values);
387
388 for (unsigned int i = 0;
389 i < scratch_data.patch_values_scalar
390 .solution_values.size();
391 ++i)
392 {
393 AssertDimension(
394 scratch_data.patch_values_system
395 .solution_values[i]
396 .size(),
397 2);
398 scratch_data.patch_values_system
399 .solution_values[i][1] =
400 scratch_data.patch_values_scalar
401 .solution_values[i];
402 }
403 }
404
405 if (update_flags & update_gradients)
406 {
407 dataset->get_function_gradients(
408 this_fe_patch_values,
409 internal::DataOutImplementation::
410 ComponentExtractor::imaginary_part,
411 scratch_data.patch_values_scalar
412 .solution_gradients);
413
414 for (unsigned int i = 0;
415 i < scratch_data.patch_values_scalar
416 .solution_gradients.size();
417 ++i)
418 {
419 AssertDimension(
420 scratch_data.patch_values_system
421 .solution_values[i]
422 .size(),
423 2);
424 scratch_data.patch_values_system
425 .solution_gradients[i][1] =
426 scratch_data.patch_values_scalar
427 .solution_gradients[i];
428 }
429 }
430
431 if (update_flags & update_hessians)
432 {
433 dataset->get_function_hessians(
434 this_fe_patch_values,
435 internal::DataOutImplementation::
436 ComponentExtractor::imaginary_part,
437 scratch_data.patch_values_scalar
438 .solution_hessians);
439
440 for (unsigned int i = 0;
441 i < scratch_data.patch_values_scalar
442 .solution_hessians.size();
443 ++i)
444 {
445 AssertDimension(
446 scratch_data.patch_values_system
447 .solution_hessians[i]
448 .size(),
449 2);
450 scratch_data.patch_values_system
451 .solution_hessians[i][1] =
452 scratch_data.patch_values_scalar
453 .solution_hessians[i];
454 }
455 }
456 }
457 else
458 {
459 scratch_data.resize_system_vectors(2 * n_components);
460
461 // This is the vector-valued, complex-valued case. In
462 // essence, we just need to do the same as above,
463 // i.e., call the functions in dataset
464 // to retrieve first the real and then the imaginary
465 // part of the solution, then copy them to the
466 // scratch_data.patch_values_system. The difference to
467 // the scalar case is that there, we could (ab)use the
468 // scratch_data.patch_values_scalar members for first
469 // the real part and then the imaginary part, copying
470 // them into the scratch_data.patch_values_system
471 // variable one after the other. We can't do this
472 // here because the solution is vector-valued, and
473 // so using the single
474 // scratch_data.patch_values_system object doesn't
475 // work.
476 //
477 // Rather, we need to come up with a temporary object
478 // for this (one for each the values, the gradients,
479 // and the hessians).
480 //
481 // Compared to the previous code path, we here
482 // first get the real and imaginary parts of the
483 // values, then the real and imaginary parts of the
484 // gradients, etc. This allows us to scope the
485 // temporary objects better
486 if (update_flags & update_values)
487 {
488 std::vector<Vector<double>> tmp(
489 scratch_data.patch_values_system.solution_values
490 .size(),
491 Vector<double>(n_components));
492
493 // First get the real part into the tmp object
494 dataset->get_function_values(
495 this_fe_patch_values,
496 internal::DataOutImplementation::
497 ComponentExtractor::real_part,
498 tmp);
499
500 // Then copy these values into the first
501 // n_components slots of the output object.
502 for (unsigned int i = 0;
503 i < scratch_data.patch_values_system
504 .solution_values.size();
505 ++i)
506 {
507 AssertDimension(
508 scratch_data.patch_values_system
509 .solution_values[i]
510 .size(),
511 2 * n_components);
512 for (unsigned int j = 0; j < n_components;
513 ++j)
514 scratch_data.patch_values_system
515 .solution_values[i][j] = tmp[i][j];
516 }
517
518 // Then do the same with the imaginary part,
519 // copying past the end of the previous set of
520 // values.
521 dataset->get_function_values(
522 this_fe_patch_values,
523 internal::DataOutImplementation::
524 ComponentExtractor::imaginary_part,
525 tmp);
526
527 for (unsigned int i = 0;
528 i < scratch_data.patch_values_system
529 .solution_values.size();
530 ++i)
531 {
532 for (unsigned int j = 0; j < n_components;
533 ++j)
534 scratch_data.patch_values_system
535 .solution_values[i][j + n_components] =
536 tmp[i][j];
537 }
538 }
539
540 // Now do the exact same thing for the gradients
541 if (update_flags & update_gradients)
542 {
543 std::vector<std::vector<Tensor<1, spacedim>>> tmp(
544 scratch_data.patch_values_system
545 .solution_gradients.size(),
546 std::vector<Tensor<1, spacedim>>(n_components));
547
548 // First the real part
549 dataset->get_function_gradients(
550 this_fe_patch_values,
551 internal::DataOutImplementation::
552 ComponentExtractor::real_part,
553 tmp);
554
555 for (unsigned int i = 0;
556 i < scratch_data.patch_values_system
557 .solution_gradients.size();
558 ++i)
559 {
560 AssertDimension(
561 scratch_data.patch_values_system
562 .solution_gradients[i]
563 .size(),
564 2 * n_components);
565 for (unsigned int j = 0; j < n_components;
566 ++j)
567 scratch_data.patch_values_system
568 .solution_gradients[i][j] = tmp[i][j];
569 }
570
571 // Then the imaginary part
572 dataset->get_function_gradients(
573 this_fe_patch_values,
574 internal::DataOutImplementation::
575 ComponentExtractor::imaginary_part,
576 tmp);
577
578 for (unsigned int i = 0;
579 i < scratch_data.patch_values_system
580 .solution_gradients.size();
581 ++i)
582 {
583 for (unsigned int j = 0; j < n_components;
584 ++j)
585 scratch_data.patch_values_system
586 .solution_gradients[i][j + n_components] =
587 tmp[i][j];
588 }
589 }
590
591 // And finally the Hessians. Same scheme as above.
592 if (update_flags & update_hessians)
593 {
594 std::vector<std::vector<Tensor<2, spacedim>>> tmp(
595 scratch_data.patch_values_system
596 .solution_gradients.size(),
597 std::vector<Tensor<2, spacedim>>(n_components));
598
599 // First the real part
600 dataset->get_function_hessians(
601 this_fe_patch_values,
602 internal::DataOutImplementation::
603 ComponentExtractor::real_part,
604 tmp);
605
606 for (unsigned int i = 0;
607 i < scratch_data.patch_values_system
608 .solution_hessians.size();
609 ++i)
610 {
611 AssertDimension(
612 scratch_data.patch_values_system
613 .solution_hessians[i]
614 .size(),
615 2 * n_components);
616 for (unsigned int j = 0; j < n_components;
617 ++j)
618 scratch_data.patch_values_system
619 .solution_hessians[i][j] = tmp[i][j];
620 }
621
622 // Then the imaginary part
623 dataset->get_function_hessians(
624 this_fe_patch_values,
625 internal::DataOutImplementation::
626 ComponentExtractor::imaginary_part,
627 tmp);
628
629 for (unsigned int i = 0;
630 i < scratch_data.patch_values_system
631 .solution_hessians.size();
632 ++i)
633 {
634 for (unsigned int j = 0; j < n_components;
635 ++j)
636 scratch_data.patch_values_system
637 .solution_hessians[i][j + n_components] =
638 tmp[i][j];
639 }
640 }
641 }
642 }
643
644 // Now set other fields we may need
645 if (update_flags & update_quadrature_points)
646 scratch_data.patch_values_system.evaluation_points =
647 this_fe_patch_values.get_quadrature_points();
648
649 const typename DoFHandler<dim, spacedim>::cell_iterator
650 dh_cell(&cell_and_index->first->get_triangulation(),
651 cell_and_index->first->level(),
652 cell_and_index->first->index(),
653 dataset->dof_handler);
654 scratch_data.patch_values_system.template set_cell<dim>(
655 dh_cell);
656
657 // Whether the solution was complex-scalar or
658 // complex-vector-valued doesn't matter -- we took it apart
659 // into several fields and so we have to call the
660 // evaluate_vector_field() function.
661 postprocessor->evaluate_vector_field(
662 scratch_data.patch_values_system,
663 scratch_data.postprocessed_values[dataset_number]);
664 }
665
666 // Now we need to copy the result of the postprocessor to
667 // the Patch object where it can then be further processed
668 // by the functions in DataOutBase
669 for (unsigned int q = 0; q < n_q_points; ++q)
670 for (unsigned int component = 0;
671 component < dataset->n_output_variables;
672 ++component)
673 patch.data(offset + component, q) =
674 scratch_data.postprocessed_values[dataset_number][q](
675 component);
676
677 // Move the counter for the output location forward as
678 // appropriate
679 offset += dataset->n_output_variables;
680 }
681 else
682 {
683 // use the given data vector directly, without a postprocessor.
684 // again, we treat single component functions separately for
685 // efficiency reasons.
686 if (n_components == 1)
687 {
688 Assert(dataset->n_output_variables == 1, ExcInternalError());
689
690 // First output the real part of the solution vector
691 dataset->get_function_values(
692 this_fe_patch_values,
693 internal::DataOutImplementation::ComponentExtractor::
694 real_part,
695 scratch_data.patch_values_scalar.solution_values);
696 for (unsigned int q = 0; q < n_q_points; ++q)
697 patch.data(offset, q) =
698 scratch_data.patch_values_scalar.solution_values[q];
699 offset += 1;
700
701 // And if there is one, also output the imaginary part. Note
702 // that the problem is scalar-valued, so we can freely add the
703 // imaginary part after the real part without having to worry
704 // that we are interleaving the real components of a vector
705 // with the imaginary components of the same vector.
706 if (dataset->is_complex_valued() == true)
707 {
708 dataset->get_function_values(
709 this_fe_patch_values,
710 internal::DataOutImplementation::ComponentExtractor::
711 imaginary_part,
712 scratch_data.patch_values_scalar.solution_values);
713 for (unsigned int q = 0; q < n_q_points; ++q)
714 patch.data(offset, q) =
715 scratch_data.patch_values_scalar.solution_values[q];
716 offset += 1;
717 }
718 }
719 else
720 {
721 scratch_data.resize_system_vectors(n_components);
722
723 // So we have a multi-component DoFHandler here. That's more
724 // complicated. If the vector is real-valued, then we can just
725 // get everything at all quadrature points and copy them into
726 // the output array. In fact, we don't have to worry at all
727 // about the interpretation of the components.
728 if (dataset->is_complex_valued() == false)
729 {
730 dataset->get_function_values(
731 this_fe_patch_values,
732 internal::DataOutImplementation::ComponentExtractor::
733 real_part,
734 scratch_data.patch_values_system.solution_values);
735 for (unsigned int component = 0; component < n_components;
736 ++component)
737 for (unsigned int q = 0; q < n_q_points; ++q)
738 patch.data(offset + component, q) =
739 scratch_data.patch_values_system.solution_values[q](
740 component);
741
742 // Increment the counter for the actual data record.
743 offset += dataset->n_output_variables;
744 }
745 else
746 // The situation is more complicated if the input vector is
747 // complex-valued. The easiest approach would have been to
748 // just have all real and then all imaginary components.
749 // This would have been conceptually easy, but it has the
750 // annoying downside that if you have a vector-valued
751 // problem (say, [u v]) then the output order would have
752 // been [u_re, v_re, u_im, v_im]. That's tolerable, but not
753 // quite so nice because one typically thinks of real and
754 // imaginary parts as belonging together. We would really
755 // like the output order to be [u_re, u_im, v_re, v_im].
756 // That, too, would have been easy to implement because one
757 // just has to interleave real and imaginary parts.
758 //
759 // But that's also not what we want. That's because if one
760 // were, for example, to solve a complex-valued Stokes
761 // problem (e.g., computing eigenfunctions of the Stokes
762 // operator), then one has solution components
763 // [[u v] p] and the proper output order is
764 // [[u_re v_re] [u_im v_im] p_re p_im].
765 // In other words, the order in which we want to output
766 // data depends on the *interpretation* of components.
767 //
768 // Doing this requires a bit more code, and also needs to
769 // be in sync with what we do in
770 // DataOut_DoFData::get_dataset_names() and
771 // DataOut_DoFData::get_nonscalar_data_ranges().
772 {
773 // Given this description, first get the real parts of
774 // all components:
775 dataset->get_function_values(
776 this_fe_patch_values,
777 internal::DataOutImplementation::ComponentExtractor::
778 real_part,
779 scratch_data.patch_values_system.solution_values);
780
781 // Then we need to distribute them to the correct
782 // location. This requires knowledge of the interpretation
783 // of components as discussed above.
784 {
785 Assert(dataset->data_component_interpretation.size() ==
786 n_components,
787 ExcInternalError());
788
789 unsigned int destination = offset;
790 for (unsigned int component = 0;
791 component < n_components;
792 /* component is updated below */)
793 {
794 switch (
795 dataset->data_component_interpretation[component])
796 {
797 case DataComponentInterpretation::
798 component_is_scalar:
799 {
800 // OK, a scalar component. Put all of the
801 // values into the current row
802 // ('destination'); then move 'component'
803 // forward by one (so we treat the next
804 // component) and 'destination' forward by
805 // two (because we're going to put the
806 // imaginary part of the current component
807 // into the next slot).
808 for (unsigned int q = 0; q < n_q_points;
809 ++q)
810 patch.data(destination, q) =
811 scratch_data.patch_values_system
812 .solution_values[q](component);
813
814 ++component;
815 destination += 2;
816
817 break;
818 }
819
820 case DataComponentInterpretation::
821 component_is_part_of_vector:
822 {
823 // A vector component. Put the
824 // spacedim
825 // components into the next set of
826 // contiguous rows
827 // ('destination+c'); then move 'component'
828 // forward by spacedim (so we get to the
829 // next component after the current vector)
830 // and 'destination' forward by two*spacedim
831 // (because we're going to put the imaginary
832 // part of the vector into the subsequent
833 // spacedim slots).
834 const unsigned int size = spacedim;
835 for (unsigned int c = 0; c < size; ++c)
836 for (unsigned int q = 0; q < n_q_points;
837 ++q)
838 patch.data(destination + c, q) =
839 scratch_data.patch_values_system
840 .solution_values[q](component + c);
841
842 component += size;
843 destination += 2 * size;
844
845 break;
846 }
847
848 case DataComponentInterpretation::
849 component_is_part_of_tensor:
850 {
851 // Same approach as for vectors above.
852 const unsigned int size =
853 spacedim * spacedim;
854 for (unsigned int c = 0; c < size; ++c)
855 for (unsigned int q = 0; q < n_q_points;
856 ++q)
857 patch.data(destination + c, q) =
858 scratch_data.patch_values_system
859 .solution_values[q](component + c);
860
861 component += size;
862 destination += 2 * size;
863
864 break;
865 }
866
867 default:
868 Assert(false, ExcNotImplemented());
869 }
870 }
871 }
872
873 // And now we need to do the same thing again for the
874 // imaginary parts, starting at the top of the list of
875 // components/destinations again.
876 dataset->get_function_values(
877 this_fe_patch_values,
878 internal::DataOutImplementation::ComponentExtractor::
879 imaginary_part,
880 scratch_data.patch_values_system.solution_values);
881 {
882 unsigned int destination = offset;
883 for (unsigned int component = 0;
884 component < n_components;
885 /* component is updated below */)
886 {
887 switch (
888 dataset->data_component_interpretation[component])
889 {
890 case DataComponentInterpretation::
891 component_is_scalar:
892 {
893 // OK, a scalar component. Put all of the
894 // values into the row past the current one
895 // ('destination+1') since 'destination' is
896 // occupied by the real part.
897 for (unsigned int q = 0; q < n_q_points;
898 ++q)
899 patch.data(destination + 1, q) =
900 scratch_data.patch_values_system
901 .solution_values[q](component);
902
903 ++component;
904 destination += 2;
905
906 break;
907 }
908
909 case DataComponentInterpretation::
910 component_is_part_of_vector:
911 {
912 // A vector component. Put the
913 // spacedim
914 // components into the set of contiguous
915 // rows that follow the real parts
916 // ('destination+spacedim+c').
917 const unsigned int size = spacedim;
918 for (unsigned int c = 0; c < size; ++c)
919 for (unsigned int q = 0; q < n_q_points;
920 ++q)
921 patch.data(destination + size + c, q) =
922 scratch_data.patch_values_system
923 .solution_values[q](component + c);
924
925 component += size;
926 destination += 2 * size;
927
928 break;
929 }
930
931 case DataComponentInterpretation::
932 component_is_part_of_tensor:
933 {
934 // Same as for vectors.
935 const unsigned int size =
936 spacedim * spacedim;
937 for (unsigned int c = 0; c < size; ++c)
938 for (unsigned int q = 0; q < n_q_points;
939 ++q)
940 patch.data(destination + size + c, q) =
941 scratch_data.patch_values_system
942 .solution_values[q](component + c);
943
944 component += size;
945 destination += 2 * size;
946
947 break;
948 }
949
950 default:
951 Assert(false, ExcNotImplemented());
952 }
953 }
954 }
955
956 // Increment the counter for the actual data record. We
957 // need to move it forward a number of positions equal to
958 // the number of components of this data set, times two
959 // because we dealt with a complex-valued input vector
960 offset += dataset->n_output_variables * 2;
961 }
962 }
963 }
964
965 // Also update the dataset_number index that we carry along with the
966 // for-loop over all data sets.
967 ++dataset_number;
968 }
969
970 // Then do the cell data. At least, we don't have to worry about
971 // complex-valued vectors/tensors since cell data is always scalar.
972 if (this->cell_data.size() != 0)
973 {
974 Assert(!cell_and_index->first->has_children(), ExcNotImplemented());
975
976 for (const auto &dataset : this->cell_data)
977 {
978 // as above, first output the real part
979 {
980 const double value =
981 dataset->get_cell_data_value(cell_and_index->second,
982 internal::DataOutImplementation::
983 ComponentExtractor::real_part);
984 for (unsigned int q = 0; q < n_q_points; ++q)
985 patch.data(offset, q) = value;
986 }
987
988 // and if there is one, also output the imaginary part
989 if (dataset->is_complex_valued() == true)
990 {
991 const double value = dataset->get_cell_data_value(
992 cell_and_index->second,
993 internal::DataOutImplementation::ComponentExtractor::
994 imaginary_part);
995 for (unsigned int q = 0; q < n_q_points; ++q)
996 patch.data(offset + 1, q) = value;
997 }
998
999 offset += (dataset->is_complex_valued() ? 2 : 1);
1000 }
1001 }
1002 }
1003
1004
1005 for (const unsigned int f : cell_and_index->first->face_indices())
1006 {
1007 // let's look up whether the neighbor behind that face is noted in the
1008 // table of cells which we treat. this can only happen if the neighbor
1009 // exists, and is on the same level as this cell, but it may also happen
1010 // that the neighbor is not a member of the range of cells over which we
1011 // loop, in which case the respective entry in the
1012 // cell_to_patch_index_map will have the value no_neighbor. (note that
1013 // since we allocated only as much space in this array as the maximum
1014 // index of the cells we loop over, not every neighbor may have its
1015 // space in it, so we have to assume that it is extended by values
1016 // no_neighbor)
1017 if (cell_and_index->first->at_boundary(f) ||
1018 (cell_and_index->first->neighbor(f)->level() !=
1019 cell_and_index->first->level()))
1020 {
1021 patch.neighbors[f] = numbers::invalid_unsigned_int;
1022 continue;
1023 }
1024
1025 const cell_iterator neighbor = cell_and_index->first->neighbor(f);
1026 Assert(static_cast<unsigned int>(neighbor->level()) <
1027 scratch_data.cell_to_patch_index_map->size(),
1028 ExcInternalError());
1029 if ((static_cast<unsigned int>(neighbor->index()) >=
1030 (*scratch_data.cell_to_patch_index_map)[neighbor->level()].size()) ||
1031 ((*scratch_data.cell_to_patch_index_map)[neighbor->level()]
1032 [neighbor->index()] ==
1033 ::DataOutBase::Patch<dim>::no_neighbor))
1034 {
1035 patch.neighbors[f] = numbers::invalid_unsigned_int;
1036 continue;
1037 }
1038
1039 // now, there is a neighbor, so get its patch number and set it for the
1040 // neighbor index
1041 patch.neighbors[f] =
1042 (*scratch_data
1043 .cell_to_patch_index_map)[neighbor->level()][neighbor->index()];
1044 }
1045
1046 const unsigned int patch_idx =
1047 (*scratch_data.cell_to_patch_index_map)[cell_and_index->first->level()]
1048 [cell_and_index->first->index()];
1049 // did we mess up the indices?
1050 Assert(patch_idx < this->patches.size(), ExcInternalError());
1051 patch.patch_index = patch_idx;
1052
1053 // Put the patch into the patches vector. instead of copying the data,
1054 // simply swap the contents to avoid the penalty of writing into another
1055 // processor's memory
1056 this->patches[patch_idx].swap(patch);
1057}
1058
1059
1060
1061template <int dim, int spacedim>
1062void
1063DataOut<dim, spacedim>::build_patches(const unsigned int n_subdivisions)
1064{
1065 AssertDimension(this->triangulation->get_reference_cells().size(), 1);
1066
1067 build_patches(this->triangulation->get_reference_cells()[0]
1068 .template get_default_linear_mapping<dim, spacedim>(),
1069 n_subdivisions,
1070 no_curved_cells);
1071}
1072
1073
1074
1075template <int dim, int spacedim>
1076void
1077DataOut<dim, spacedim>::build_patches(const Mapping<dim, spacedim> &mapping,
1078 const unsigned int n_subdivisions_,
1079 const CurvedCellRegion curved_region)
1080{
1081 hp::MappingCollection<dim, spacedim> mapping_collection(mapping);
1082
1083 build_patches(mapping_collection, n_subdivisions_, curved_region);
1084}
1085
1086
1087
1088template <int dim, int spacedim>
1089void
1090DataOut<dim, spacedim>::build_patches(
1091 const hp::MappingCollection<dim, spacedim> &mapping,
1092 const unsigned int n_subdivisions_,
1093 const CurvedCellRegion curved_region)
1094{
1095 // Check consistency of redundant template parameter
1096 Assert(dim == dim, ExcDimensionMismatch(dim, dim));
1097
1098 Assert(this->triangulation != nullptr,
1099 Exceptions::DataOutImplementation::ExcNoTriangulationSelected());
1100
1101 const unsigned int n_subdivisions =
1102 (n_subdivisions_ != 0) ? n_subdivisions_ : this->default_subdivisions;
1103 Assert(n_subdivisions >= 1,
1104 Exceptions::DataOutImplementation::ExcInvalidNumberOfSubdivisions(
1105 n_subdivisions));
1106
1107 this->validate_dataset_names();
1108
1109 // First count the cells we want to create patches of. Also fill the object
1110 // that maps the cell indices to the patch numbers, as this will be needed
1111 // for generation of neighborship information.
1112 // Note, there is a confusing mess of different indices here at play:
1113 // - patch_index: the index of a patch in all_cells
1114 // - cell->index: only unique on each level, used in cell_to_patch_index_map
1115 // - active_index: index for a cell when counting from begin_active() using
1116 // ++cell (identical to cell->active_cell_index())
1117 // - cell_index: unique index of a cell counted using
1118 // next_cell_function() starting from first_cell_function()
1119 //
1120 // It turns out that we create one patch for each selected cell, so
1121 // patch_index==cell_index.
1122 //
1123 // Now construct the map such that
1124 // cell_to_patch_index_map[cell->level][cell->index] = patch_index
1125 std::vector<std::vector<unsigned int>> cell_to_patch_index_map;
1126 cell_to_patch_index_map.resize(this->triangulation->n_levels());
1127 for (unsigned int l = 0; l < this->triangulation->n_levels(); ++l)
1128 {
1129 // max_index is the largest cell->index on level l
1130 unsigned int max_index = 0;
1131 for (cell_iterator cell = first_cell_function(*this->triangulation);
1132 cell != this->triangulation->end();
1133 cell = next_cell_function(*this->triangulation, cell))
1134 if (static_cast<unsigned int>(cell->level()) == l)
1135 max_index =
1136 std::max(max_index, static_cast<unsigned int>(cell->index()));
1137
1138 cell_to_patch_index_map[l].resize(
1139 max_index + 1, ::DataOutBase::Patch<dim, spacedim>::no_neighbor);
1140 }
1141
1142 // will be all_cells[patch_index] = pair(cell, active_index)
1143 std::vector<std::pair<cell_iterator, unsigned int>> all_cells;
1144 {
1145 // important: we need to compute the active_index of the cell in the range
1146 // 0..n_active_cells() because this is where we need to look up cell
1147 // data from (cell data vectors do not have the length distance computed by
1148 // first_cell_function/next_cell_function because this might skip
1149 // some values (FilteredIterator).
1150 auto active_cell = this->triangulation->begin_active();
1151 unsigned int active_index = 0;
1152 cell_iterator cell = first_cell_function(*this->triangulation);
1153 for (; cell != this->triangulation->end();
1154 cell = next_cell_function(*this->triangulation, cell))
1155 {
1156 // move forward until active_cell points at the cell (cell) we are
1157 // looking at to compute the current active_index
1158 while (active_cell != this->triangulation->end() && cell->is_active() &&
1159 decltype(active_cell)(cell) != active_cell)
1160 {
1161 ++active_cell;
1162 ++active_index;
1163 }
1164
1165 Assert(static_cast<unsigned int>(cell->level()) <
1166 cell_to_patch_index_map.size(),
1167 ExcInternalError());
1168 Assert(static_cast<unsigned int>(cell->index()) <
1169 cell_to_patch_index_map[cell->level()].size(),
1170 ExcInternalError());
1171 Assert(active_index < this->triangulation->n_active_cells(),
1172 ExcInternalError());
1173 cell_to_patch_index_map[cell->level()][cell->index()] =
1174 all_cells.size();
1175
1176 all_cells.emplace_back(cell, active_index);
1177 }
1178 }
1179
1180 this->patches.clear();
1181 this->patches.resize(all_cells.size());
1182
1183 // Now create a default object for the WorkStream object to work with. The
1184 // first step is to count how many output data sets there will be. This is,
1185 // in principle, just the number of components of each data set, but we
1186 // need to allocate two entries per component if there are
1187 // complex-valued input data (unless we use a postprocessor on this
1188 // output -- all postprocessor outputs are real-valued)
1189 unsigned int n_datasets = 0;
1190 for (unsigned int i = 0; i < this->cell_data.size(); ++i)
1191 n_datasets += (this->cell_data[i]->is_complex_valued() &&
1192 (this->cell_data[i]->postprocessor == nullptr) ?
1193 2 :
1194 1);
1195 for (unsigned int i = 0; i < this->dof_data.size(); ++i)
1196 n_datasets += (this->dof_data[i]->n_output_variables *
1197 (this->dof_data[i]->is_complex_valued() &&
1198 (this->dof_data[i]->postprocessor == nullptr) ?
1199 2 :
1200 1));
1201
1202 std::vector<unsigned int> n_postprocessor_outputs(this->dof_data.size());
1203 for (unsigned int dataset = 0; dataset < this->dof_data.size(); ++dataset)
1204 if (this->dof_data[dataset]->postprocessor)
1205 n_postprocessor_outputs[dataset] =
1206 this->dof_data[dataset]->n_output_variables;
1207 else
1208 n_postprocessor_outputs[dataset] = 0;
1209
1210 const CurvedCellRegion curved_cell_region =
1211 (n_subdivisions < 2 ? no_curved_cells : curved_region);
1212
1213 UpdateFlags update_flags = update_values;
1214 if (curved_cell_region != no_curved_cells)
1215 update_flags |= update_quadrature_points;
1216
1217 for (unsigned int i = 0; i < this->dof_data.size(); ++i)
1218 if (this->dof_data[i]->postprocessor)
1219 update_flags |=
1220 this->dof_data[i]->postprocessor->get_needed_update_flags();
1221 // perhaps update_normal_vectors is present, which would only be useful on
1222 // faces, but we may not use it here.
1223 Assert(
1224 !(update_flags & update_normal_vectors),
1225 ExcMessage(
1226 "The update of normal vectors may not be requested for evaluation of "
1227 "data on cells via DataPostprocessor."));
1228
1229 internal::DataOutImplementation::ParallelData<dim, spacedim> thread_data(
1230 n_datasets,
1231 n_subdivisions,
1232 n_postprocessor_outputs,
1233 mapping,
1234 this->get_fes(),
1235 update_flags,
1236 cell_to_patch_index_map);
1237
1238 auto worker = [this, n_subdivisions, curved_cell_region](
1239 const std::pair<cell_iterator, unsigned int> *cell_and_index,
1240 internal::DataOutImplementation::ParallelData<dim, spacedim>
1241 &scratch_data,
1242 // this function doesn't actually need a copy data object --
1243 // it just writes everything right into the output array
1244 int) {
1245 this->build_one_patch(cell_and_index,
1246 scratch_data,
1247 n_subdivisions,
1248 curved_cell_region);
1249 };
1250
1251 // now build the patches in parallel
1252 if (all_cells.size() > 0)
1253 WorkStream::run(all_cells.data(),
1254 all_cells.data() + all_cells.size(),
1255 worker,
1256 // no copy-local-to-global function needed here
1257 std::function<void(const int)>(),
1258 thread_data,
1259 /* dummy CopyData object = */ 0,
1260 // experimenting shows that we can make things run a bit
1261 // faster if we increase the number of cells we work on
1262 // per item (i.e., WorkStream's chunk_size argument,
1263 // about 10% improvement) and the items in flight at any
1264 // given time (another 5% on the testcase discussed in
1265 // @ref workstream_paper, on 32 cores) and if
1266 8 * MultithreadInfo::n_threads(),
1267 64);
1268}
1269
1270
1271
1272template <int dim, int spacedim>
1273void
1274DataOut<dim, spacedim>::set_cell_selection(
1275 const std::function<cell_iterator(const Triangulation<dim, spacedim> &)>
1276 & first_cell,
1277 const std::function<cell_iterator(const Triangulation<dim, spacedim> &,
1278 const cell_iterator &)> &next_cell)
1279{
1280 first_cell_function = first_cell;
1281 next_cell_function = next_cell;
1282}
1283
1284
1285
1286template <int dim, int spacedim>
1287void
1288DataOut<dim, spacedim>::set_cell_selection(
1289 const FilteredIterator<cell_iterator> &filtered_iterator)
1290{
1291 const auto first_cell =
1292 [filtered_iterator](const Triangulation<dim, spacedim> &triangulation) {
1293 // Create a copy of the filtered iterator so that we can
1294 // call a non-const function -- though we are really only
1295 // interested in the return value of that function, not the
1296 // state of the object
1297 FilteredIterator<cell_iterator> x = filtered_iterator;
1298 return x.set_to_next_positive(triangulation.begin());
1299 };
1300
1301
1302 const auto next_cell =
1303 [filtered_iterator](const Triangulation<dim, spacedim> &,
1304 const cell_iterator &cell) {
1305 // Create a copy of the filtered iterator so that we can
1306 // call a non-const function -- though we are really only
1307 // interested in the return value of that function, not the
1308 // state of the object
1309 FilteredIterator<cell_iterator> x = filtered_iterator;
1310
1311 // Set the iterator to 'cell'. Since 'cell' must satisfy the
1312 // predicate (that's how it was created), set_to_next_positive
1313 // simply sets the iterator to 'cell'.
1314 x.set_to_next_positive(cell);
1315
1316 // Advance by one:
1317 ++x;
1318
1319 return x;
1320 };
1321
1322 set_cell_selection(first_cell, next_cell);
1323}
1324
1325
1326
1327template <int dim, int spacedim>
1328const std::pair<typename DataOut<dim, spacedim>::FirstCellFunctionType,
1329 typename DataOut<dim, spacedim>::NextCellFunctionType>
1330DataOut<dim, spacedim>::get_cell_selection() const
1331{
1332 return std::make_pair(first_cell_function, next_cell_function);
1333}
1334
1335
1336
1337// explicit instantiations
1338#include "data_out.inst"
1339
1340DEAL_II_NAMESPACE_CLOSE
DataOut::DataOut
DataOut()
Definition data_out.cc:68
DataOut::build_patches
virtual void build_patches(const unsigned int n_subdivisions=0)
Definition data_out.cc:1063
DataOut::CurvedCellRegion
CurvedCellRegion
Definition data_out.h:186
DataOut::NextCellFunctionType
typename std::function< cell_iterator(const Triangulation< dim, spacedim > &, const cell_iterator &)> NextCellFunctionType
Definition data_out.h:170
DataOut::build_one_patch
void build_one_patch(const std::pair< cell_iterator, unsigned int > *cell_and_index, internal::DataOutImplementation::ParallelData< dim, spacedim > &scratch_data, const unsigned int n_subdivisions, const CurvedCellRegion curved_cell_region)
Definition data_out.cc:96
DataOut::get_cell_selection
const std::pair< FirstCellFunctionType, NextCellFunctionType > get_cell_selection() const
Definition data_out.cc:1330
DataOut::cell_iterator
typename DataOut_DoFData< dim, dim, spacedim, spacedim >::cell_iterator cell_iterator
Definition data_out.h:155
DataOut::set_cell_selection
void set_cell_selection(const std::function< cell_iterator(const Triangulation< dim, spacedim > &)> &first_cell, const std::function< cell_iterator(const Triangulation< dim, spacedim > &, const cell_iterator &)> &next_cell)
Definition data_out.cc:1274
DataPostprocessor::get_needed_update_flags
virtual UpdateFlags get_needed_update_flags() const =0
DataPostprocessor::evaluate_vector_field
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &input_data, std::vector< Vector< double > > &computed_quantities) const
Definition data_postprocessor.cc:60
DataPostprocessor::evaluate_scalar_field
virtual void evaluate_scalar_field(const DataPostprocessorInputs::Scalar< dim > &input_data, std::vector< Vector< double > > &computed_quantities) const
Definition data_postprocessor.cc:49
FEValuesBase::get_quadrature_points
const std::vector< Point< spacedim > > & get_quadrature_points() const
FEValuesBase::get_mapping
const Mapping< dim, spacedim > & get_mapping() const
FEValuesBase::n_quadrature_points
const unsigned int n_quadrature_points
Definition fe_values.h:2433
FEValuesBase::get_fe
const FiniteElement< dim, spacedim > & get_fe() const
FilteredIterator::set_to_next_positive
FilteredIterator & set_to_next_positive(const BaseIterator &bi)
Definition filtered_iterator.h:1221
FiniteElementData::n_components
unsigned int n_components() const
Mapping
Abstract base class for mapping classes.
Definition mapping.h:317
Mapping::get_vertices
virtual boost::container::small_vector< Point< spacedim >, GeometryInfo< dim >::vertices_per_cell > get_vertices(const typename Triangulation< dim, spacedim >::cell_iterator &cell) const
MultithreadInfo::n_threads
static unsigned int n_threads()
Definition multithread_info.cc:128
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:472
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:473
vertices
Point< 3 > vertices[4]
Definition data_out_base.cc:273
dof_accessor.h
dof_handler.h
fe_values.h
fe_dgq.h
first
Point< 2 > first
Definition grid_out.cc:4615
Exceptions::DataOutImplementation::ExcInvalidNumberOfSubdivisions
static ::ExceptionBase & ExcInvalidNumberOfSubdivisions(int arg1)
StandardExceptions::ExcNotImplemented
static ::ExceptionBase & ExcNotImplemented()
Assert
#define Assert(cond, exc)
Definition exceptions.h:1614
AssertDimension
#define AssertDimension(dim1, dim2)
Definition exceptions.h:1787
StandardExceptions::ExcInternalError
static ::ExceptionBase & ExcInternalError()
Exceptions::DataOutImplementation::ExcNoTriangulationSelected
static ::ExceptionBase & ExcNoTriangulationSelected()
StandardExceptions::ExcDimensionMismatch
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
StandardExceptions::ExcMessage
static ::ExceptionBase & ExcMessage(std::string arg1)
DoFHandler::cell_iterator
typename ActiveSelector::cell_iterator cell_iterator
Definition dof_handler.h:469
UpdateFlags
UpdateFlags
Definition fe_update_flags.h:65
update_hessians
@ update_hessians
Second derivatives of shape functions.
Definition fe_update_flags.h:88
update_values
@ update_values
Shape function values.
Definition fe_update_flags.h:76
update_normal_vectors
@ update_normal_vectors
Normal vectors.
Definition fe_update_flags.h:142
update_gradients
@ update_gradients
Shape function gradients.
Definition fe_update_flags.h:82
update_quadrature_points
@ update_quadrature_points
Transformed quadrature points.
Definition fe_update_flags.h:128
fe_values.h
WorkStream::run
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)
Definition work_stream.h:1270
numbers::invalid_unsigned_int
static const unsigned int invalid_unsigned_int
Definition types.h:213
std::max
::VectorizedArray< Number, width > max(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
Definition vectorization.h:6024
data_out.h
triangulation
const ::parallel::distributed::Triangulation< dim, spacedim > * triangulation
Definition p4est_wrappers.cc:69
DataOutBase::Patch::patch_index
unsigned int patch_index
Definition data_out_base.h:298
DataOutBase::Patch::reference_cell
ReferenceCell reference_cell
Definition data_out_base.h:347
DataOutBase::Patch::data
Table< 2, float > data
Definition data_out_base.h:328
DataOutBase::Patch::space_dim
static const unsigned int space_dim
Definition data_out_base.h:261
DataOutBase::Patch::n_subdivisions
unsigned int n_subdivisions
Definition data_out_base.h:305
DataOutBase::Patch::vertices
std::array< Point< spacedim >, GeometryInfo< dim >::vertices_per_cell > vertices
Definition data_out_base.h:280
DataOutBase::Patch::neighbors
std::array< unsigned int, GeometryInfo< dim >::faces_per_cell > neighbors
Definition data_out_base.h:292
internal::DataOutImplementation::ParallelDataBase::get_present_fe_values
const FEValuesBase< dim, spacedim > & get_present_fe_values(const unsigned int dataset) const
internal::DataOutImplementation::ParallelDataBase::patch_values_scalar
DataPostprocessorInputs::Scalar< spacedim > patch_values_scalar
Definition data_out_dof_data.h:437
internal::DataOutImplementation::ParallelDataBase::postprocessed_values
std::vector< std::vector<::Vector< double > > > postprocessed_values
Definition data_out_dof_data.h:439
internal::DataOutImplementation::ParallelDataBase::patch_values_system
DataPostprocessorInputs::Vector< spacedim > patch_values_system
Definition data_out_dof_data.h:438
internal::DataOutImplementation::ParallelDataBase::reinit_all_fe_values
void reinit_all_fe_values(std::vector< std::shared_ptr< DataEntryBase< dim, spacedim > > > &dof_data, const typename ::Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face=numbers::invalid_unsigned_int)
internal::DataOutImplementation::ParallelDataBase::resize_system_vectors
void resize_system_vectors(const unsigned int n_components)
internal::DataOutImplementation::ParallelData::cell_to_patch_index_map
const std::vector< std::vector< unsigned int > > * cell_to_patch_index_map
Definition data_out.h:56
internal::DataOutImplementation::ParallelData::ParallelData
ParallelData(const unsigned int n_datasets, const unsigned int n_subdivisions, const std::vector< unsigned int > &n_postprocessor_outputs, const ::hp::MappingCollection< dim, spacedim > &mapping, const std::vector< std::shared_ptr<::hp::FECollection< dim, spacedim > > > &finite_elements, const UpdateFlags update_flags, const std::vector< std::vector< unsigned int > > &cell_to_patch_index_map)
Definition data_out.cc:43
tria_iterator.h
work_stream.h
Generated by doxygen 1.9.7