data_out.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 1999 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_data_out_h
#define dealii_data_out_h
 
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/grid/filtered_iterator.h>
 
#include <deal.II/numerics/data_out_dof_data.h>
 
#include <memory>
 
DEAL_II_NAMESPACE_OPEN
 
namespace internal
{
  namespace DataOutImplementation
  {
    template <int dim, int spacedim>
    struct ParallelData : public ParallelDataBase<dim, spacedim>
    {
      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);
 
      std::vector<Point<spacedim>> patch_evaluation_points;
 
      const std::vector<std::vector<unsigned int>> *cell_to_patch_index_map;
    };
  } // namespace DataOutImplementation
} // namespace internal
 
 
 
template <int dim, int spacedim = dim>
class DataOut : public DataOut_DoFData<dim, dim, spacedim, spacedim>
{
public:
  using cell_iterator =
    typename DataOut_DoFData<dim, dim, spacedim, spacedim>::cell_iterator;
 
  using FirstCellFunctionType =
    typename std::function<cell_iterator(const Triangulation<dim, spacedim> &)>;
 
  using NextCellFunctionType =
    typename std::function<cell_iterator(const Triangulation<dim, spacedim> &,
                                         const cell_iterator &)>;
 
  enum CurvedCellRegion
  {
    no_curved_cells,
 
    curved_boundary,
 
    curved_inner_cells
  };
 
  DataOut();
 
  virtual void
  build_patches(const unsigned int n_subdivisions = 0);
 
  virtual void
  build_patches(const Mapping<dim, spacedim> &mapping,
                const unsigned int            n_subdivisions = 0,
                const CurvedCellRegion        curved_region  = curved_boundary);
 
  virtual void
  build_patches(const hp::MappingCollection<dim, spacedim> &mapping,
                const unsigned int                          n_subdivisions = 0,
                const CurvedCellRegion curved_region = curved_boundary);
 
  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);
 
  void
  set_cell_selection(const FilteredIterator<cell_iterator> &filtered_iterator);
 
  std::pair<FirstCellFunctionType, NextCellFunctionType>
  get_cell_selection() const;
 
private:
  std::function<cell_iterator(const Triangulation<dim, spacedim> &)>
    first_cell_function;
 
  std::function<cell_iterator(const Triangulation<dim, spacedim> &,
                              const cell_iterator &)>
    next_cell_function;
 
  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);
};
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif