data_postprocessor.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2007 - 2022 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_postprocessor_h
#define dealii_data_postprocessor_h
 
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/point.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/tensor.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/fe/fe_update_flags.h>
 
#include <deal.II/lac/vector.h>
 
#include <deal.II/numerics/data_component_interpretation.h>
 
#include <boost/any.hpp>
 
#include <string>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
 
namespace DataPostprocessorInputs
{
  template <int spacedim>
  struct CommonInputs
  {
    CommonInputs();
 
    std::vector<Tensor<1, spacedim>> normals;
 
    std::vector<Point<spacedim>> evaluation_points;
 
    template <int dim>
    void
    set_cell(const typename DoFHandler<dim, spacedim>::cell_iterator &cell);
 
    template <int dim>
    void
    set_cell_and_face(
      const typename DoFHandler<dim, spacedim>::cell_iterator &cell,
      const unsigned int                                       face_number);
 
    template <typename DoFHandlerType>
    DEAL_II_DEPRECATED void
    set_cell(const typename DoFHandlerType::cell_iterator &cell);
 
    template <int dim>
    typename DoFHandler<dim, spacedim>::cell_iterator
    get_cell() const;
 
    template <typename DoFHandlerType>
    DEAL_II_DEPRECATED typename DoFHandlerType::cell_iterator
    get_cell() const;
 
    unsigned int
    get_face_number() const;
 
  private:
    boost::any cell;
 
    unsigned int face_number;
  };
 
  template <int spacedim>
  struct Scalar : public CommonInputs<spacedim>
  {
    std::vector<double> solution_values;
 
    std::vector<Tensor<1, spacedim>> solution_gradients;
 
    std::vector<Tensor<2, spacedim>> solution_hessians;
  };
 
 
 
  template <int spacedim>
  struct Vector : public CommonInputs<spacedim>
  {
    std::vector<::Vector<double>> solution_values;
 
    std::vector<std::vector<Tensor<1, spacedim>>> solution_gradients;
 
    std::vector<std::vector<Tensor<2, spacedim>>> solution_hessians;
  };
 
} // namespace DataPostprocessorInputs
 
 
template <int dim>
class DataPostprocessor : public Subscriptor
{
public:
  virtual ~DataPostprocessor() override = default;
 
  virtual void
  evaluate_scalar_field(const DataPostprocessorInputs::Scalar<dim> &input_data,
                        std::vector<Vector<double>> &computed_quantities) const;
 
  virtual void
  evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
                        std::vector<Vector<double>> &computed_quantities) const;
 
  virtual std::vector<std::string>
  get_names() const = 0;
 
  virtual std::vector<DataComponentInterpretation::DataComponentInterpretation>
  get_data_component_interpretation() const;
 
  virtual UpdateFlags
  get_needed_update_flags() const = 0;
};
 
 
 
template <int dim>
class DataPostprocessorScalar : public DataPostprocessor<dim>
{
public:
  DataPostprocessorScalar(const std::string &name,
                          const UpdateFlags  update_flags);
 
  virtual std::vector<std::string>
  get_names() const override;
 
  virtual std::vector<DataComponentInterpretation::DataComponentInterpretation>
  get_data_component_interpretation() const override;
 
  virtual UpdateFlags
  get_needed_update_flags() const override;
 
private:
  const std::string name;
  const UpdateFlags update_flags;
};
 
 
 
template <int dim>
class DataPostprocessorVector : public DataPostprocessor<dim>
{
public:
  DataPostprocessorVector(const std::string &name,
                          const UpdateFlags  update_flags);
 
  virtual std::vector<std::string>
  get_names() const override;
 
  virtual std::vector<DataComponentInterpretation::DataComponentInterpretation>
  get_data_component_interpretation() const override;
 
  virtual UpdateFlags
  get_needed_update_flags() const override;
 
private:
  const std::string name;
  const UpdateFlags update_flags;
};
 
 
 
template <int dim>
class DataPostprocessorTensor : public DataPostprocessor<dim>
{
public:
  DataPostprocessorTensor(const std::string &name,
                          const UpdateFlags  update_flags);
 
  virtual std::vector<std::string>
  get_names() const override;
 
  virtual std::vector<DataComponentInterpretation::DataComponentInterpretation>
  get_data_component_interpretation() const override;
 
  virtual UpdateFlags
  get_needed_update_flags() const override;
 
private:
  const std::string name;
  const UpdateFlags update_flags;
};
 
 
 
namespace DataPostprocessors
{
  template <int dim>
  class BoundaryIds : public DataPostprocessorScalar<dim>
  {
  public:
    BoundaryIds();
 
    virtual void
    evaluate_scalar_field(
      const DataPostprocessorInputs::Scalar<dim> &inputs,
      std::vector<Vector<double>> &computed_quantities) const override;
  };
} // namespace DataPostprocessors
 
 
 
#ifndef DOXYGEN
// -------------------- template functions ----------------------
 
namespace DataPostprocessorInputs
{
  template <int spacedim>
  template <typename DoFHandlerType>
  void
  CommonInputs<spacedim>::set_cell(
    const typename DoFHandlerType::cell_iterator &new_cell)
  {
    return set_cell<DoFHandlerType::dimension>(new_cell);
  }
 
 
 
  template <int spacedim>
  template <int dim>
  void
  CommonInputs<spacedim>::set_cell(
    const typename DoFHandler<dim, spacedim>::cell_iterator &new_cell)
  {
    // see if we had previously already stored a cell that has the same
    // data type; if so, reuse the memory location and avoid calling 'new'
    // inside boost::any
    if (typename DoFHandler<dim, spacedim>::cell_iterator *storage_location =
          boost::any_cast<typename DoFHandler<dim, spacedim>::cell_iterator>(
            &cell))
      *storage_location = new_cell;
    else
      // if we had nothing stored before, or if we had stored a different
      // data type, just let boost::any replace things
      cell = new_cell;
 
    // Also reset the face number, just to make sure nobody
    // accidentally uses an outdated value.
    face_number = numbers::invalid_unsigned_int;
  }
 
 
 
  template <int spacedim>
  template <int dim>
  void
  CommonInputs<spacedim>::set_cell_and_face(
    const typename DoFHandler<dim, spacedim>::cell_iterator &new_cell,
    const unsigned int                                       new_face_number)
  {
    set_cell<dim>(new_cell);
    face_number = new_face_number;
  }
 
 
 
  template <int spacedim>
  template <typename DoFHandlerType>
  typename DoFHandlerType::cell_iterator
  CommonInputs<spacedim>::get_cell() const
  {
    return get_cell<DoFHandlerType::dimension>();
  }
 
 
 
  template <int spacedim>
  template <int dim>
  typename DoFHandler<dim, spacedim>::cell_iterator
  CommonInputs<spacedim>::get_cell() const
  {
    Assert(cell.empty() == false,
           ExcMessage(
             "You are trying to access the cell associated with a "
             "DataPostprocessorInputs::Scalar object for which no cell has "
             "been set."));
    Assert((boost::any_cast<typename DoFHandler<dim, spacedim>::cell_iterator>(
              &cell) != nullptr),
           ExcMessage(
             "You are trying to access the cell associated with a "
             "DataPostprocessorInputs::Scalar with a DoFHandler type that is "
             "different from the type with which it has been set. For example, "
             "if the cell for which output is currently being generated "
             "belongs to a DoFHandler<2, 3> object, then you can only call the "
             "current function with a template argument equal to "
             "DoFHandler<2, 3>, but not with any other class type or dimension "
             "template argument."));
 
    return boost::any_cast<typename DoFHandler<dim, spacedim>::cell_iterator>(
      cell);
  }
} // namespace DataPostprocessorInputs
 
#endif
 
DEAL_II_NAMESPACE_CLOSE
 
#endif