data_out_faces.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2000 - 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_faces_h
#define dealii_data_out_faces_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/numerics/data_out.h>
 
#include <string>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
 
namespace internal
{
  namespace DataOutFacesImplementation
  {
    template <int dim, int spacedim>
    struct ParallelData
      : public internal::DataOutImplementation::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);
 
      std::vector<Point<spacedim>> patch_evaluation_points;
    };
  } // namespace DataOutFacesImplementation
} // namespace internal
 
 
template <int dim, typename DoFHandlerType = DoFHandler<dim>>
class DataOutFaces : public DataOut_DoFData<DoFHandlerType,
                                            DoFHandlerType::dimension - 1,
                                            DoFHandlerType::dimension>
{
public:
  static const unsigned int dimension = DoFHandlerType::dimension;
 
  static const unsigned int space_dimension = DoFHandlerType::space_dimension;
 
  using cell_iterator = typename DataOut_DoFData<DoFHandlerType,
                                                 dimension - 1,
                                                 dimension>::cell_iterator;
 
  DataOutFaces(const bool surface_only = true);
 
  virtual void
  build_patches(const unsigned int n_subdivisions = 0);
 
  virtual void
  build_patches(const Mapping<dimension> &mapping,
                const unsigned int        n_subdivisions = 0);
 
  using FaceDescriptor = typename std::pair<cell_iterator, unsigned int>;
 
 
  virtual FaceDescriptor
  first_face();
 
  virtual FaceDescriptor
  next_face(const FaceDescriptor &face);
 
private:
  const bool surface_only;
 
  void
  build_one_patch(
    const FaceDescriptor *cell_and_face,
    internal::DataOutFacesImplementation::ParallelData<dimension, dimension>
      &                                                 data,
    DataOutBase::Patch<dimension - 1, space_dimension> &patch);
};
 
namespace Legacy
{
  template <int dim, typename DoFHandlerType = DoFHandler<dim>>
  using DataOutFaces = ::DataOutFaces<dim, DoFHandlerType>;
} // namespace Legacy
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif