data_postprocessor.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2007 - 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_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/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
  {
    std::vector<Tensor<1, spacedim>> normals;

    std::vector<Point<spacedim>> evaluation_points;

    template <typename DoFHandlerType>
    void
    set_cell(const typename DoFHandlerType::cell_iterator &cell);

    template <typename DoFHandlerType>
    typename DoFHandlerType::cell_iterator
    get_cell() const;

  private:
    boost::any cell;
  };

  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;
};



#ifndef DOXYGEN
// -------------------- template functions ----------------------

namespace DataPostprocessorInputs
{
  template <int spacedim>
  template <typename DoFHandlerType>
  void
  CommonInputs<spacedim>::set_cell(
    const typename DoFHandlerType::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 DoFHandlerType::cell_iterator *storage_location =
          boost::any_cast<typename DoFHandlerType::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;
  }



  template <int spacedim>
  template <typename DoFHandlerType>
  typename DoFHandlerType::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 DoFHandlerType::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 hp::DoFHandler<2,3> object, then you can "
             "only call the current function with a template argument "
             "equal to hp::DoFHandler<2,3>, but not with any other class "
             "type or dimension template argument."));
    return boost::any_cast<typename DoFHandlerType::cell_iterator>(cell);
  }
} // namespace DataPostprocessorInputs

#endif

DEAL_II_NAMESPACE_CLOSE

#endif