data_postprocessor.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2007 - 2016 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii__data_postprocessor_h
#define dealii__data_postprocessor_h



#include <deal.II/base/subscriptor.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/point.h>
#include <deal.II/lac/vector.h>
#include <deal.II/fe/fe_update_flags.h>
#include <deal.II/numerics/data_component_interpretation.h>

#include <boost/any.hpp>

#include <vector>
#include <string>

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

}


template <int dim>
class DataPostprocessor: public Subscriptor
{
public:

  virtual ~DataPostprocessor ();

  virtual
  void
  evaluate_scalar_field (const DataPostprocessorInputs::Scalar<dim> &input_data,
                         std::vector<Vector<double> >               &computed_quantities) const;

  virtual
  void
  compute_derived_quantities_scalar (const std::vector<double>         &solution_values,
                                     const std::vector<Tensor<1,dim> > &solution_gradients,
                                     const std::vector<Tensor<2,dim> > &solution_hessians,
                                     const std::vector<Point<dim> >    &normals,
                                     const std::vector<Point<dim> >    &evaluation_points,
                                     std::vector<Vector<double> >      &computed_quantities) const DEAL_II_DEPRECATED;

  virtual
  void
  evaluate_vector_field (const DataPostprocessorInputs::Vector<dim> &input_data,
                         std::vector<Vector<double> >               &computed_quantities) const;

  virtual
  void
  compute_derived_quantities_vector (const std::vector<Vector<double> >              &solution_values,
                                     const std::vector<std::vector<Tensor<1,dim> > > &solution_gradients,
                                     const std::vector<std::vector<Tensor<2,dim> > > &solution_hessians,
                                     const std::vector<Point<dim> >                  &normals,
                                     const std::vector<Point<dim> >                  &evaluation_points,
                                     std::vector<Vector<double> >                    &computed_quantities) const DEAL_II_DEPRECATED;

  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;

  virtual
  std::vector<DataComponentInterpretation::DataComponentInterpretation>
  get_data_component_interpretation () const;

  virtual UpdateFlags get_needed_update_flags () const;

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;

  virtual
  std::vector<DataComponentInterpretation::DataComponentInterpretation>
  get_data_component_interpretation () const;

  virtual UpdateFlags get_needed_update_flags () const;

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) != 0,
           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);
  }
}

#endif

DEAL_II_NAMESPACE_CLOSE

#endif