data_out.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2020 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.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 Mapping<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, typename DoFHandlerType = DoFHandler<dim>>
class DataOut : public DataOut_DoFData<DoFHandlerType,
                                       DoFHandlerType::dimension,
                                       DoFHandlerType::space_dimension>
{
public:
  static_assert(dim == DoFHandlerType::dimension,
                "The dimension given explicitly as a template argument to "
                "this class must match the dimension of the DoFHandler "
                "template argument");
  static constexpr unsigned int spacedim = DoFHandlerType::space_dimension;

  using cell_iterator =
    typename DataOut_DoFData<DoFHandlerType,
                             DoFHandlerType::dimension,
                             DoFHandlerType::space_dimension>::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<DoFHandlerType::dimension,
                              DoFHandlerType::space_dimension> &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);

  const std::pair<FirstCellFunctionType, NextCellFunctionType>
  get_cell_selection() const;

  DEAL_II_DEPRECATED
  virtual cell_iterator
  first_cell();

  DEAL_II_DEPRECATED
  virtual cell_iterator
  next_cell(const cell_iterator &cell);

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;

  DEAL_II_DEPRECATED
  virtual cell_iterator
  first_locally_owned_cell();

  DEAL_II_DEPRECATED
  virtual cell_iterator
  next_locally_owned_cell(const cell_iterator &cell);

  void
  build_one_patch(const std::pair<cell_iterator, unsigned int> *cell_and_index,
                  internal::DataOutImplementation::ParallelData<
                    DoFHandlerType::dimension,
                    DoFHandlerType::space_dimension> &scratch_data,
                  const unsigned int                  n_subdivisions,
                  const CurvedCellRegion              curved_cell_region);
};



DEAL_II_NAMESPACE_CLOSE

#endif