data_out_stack.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2021 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_stack_h
#define dealii_data_out_stack_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/data_out_base.h>
#include <deal.II/base/smartpointer.h>
 
#include <deal.II/lac/vector.h>
 
#include <deal.II/numerics/data_out_dof_data.h>
 
#include <string>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declaration
#ifndef DOXYGEN
template <int dim, int spacedim>
class DoFHandler;
#endif
 
template <int dim, int spacedim = dim, typename DoFHandlerType = void>
class DataOutStack;
 
#ifndef DOXYGEN
// prevent doxygen from complaining about potential recursive class relations
template <int dim, int spacedim, typename DoFHandlerType>
class DataOutStack : public DataOutStack<dim, spacedim, void>
{
public:
  DEAL_II_DEPRECATED
  DataOutStack()
    : DataOutStack<dim, spacedim, void>()
  {}
};
#endif // DOXYGEN
 
template <int dim, int spacedim>
class DataOutStack<dim, spacedim, void>
  : public DataOutInterface<dim + 1, spacedim + 1>
{
  static_assert(dim < 3,
                "Because this class stacks data into the (dim+1)st "
                "dimension to create graphical output, it only works for "
                "dim<3.");
  static_assert(dim == spacedim,
                "This class is not implemented for dim != spacedim.");
 
public:
  static constexpr int patch_dim      = dim + 1;
  static constexpr int patch_spacedim = spacedim + 1;
 
  enum VectorType
  {
    cell_vector,
    dof_vector
  };
 
  virtual ~DataOutStack() override = default;
 
  void
  new_parameter_value(const double parameter_value,
                      const double parameter_step);
 
  void
  attach_dof_handler(const DoFHandler<dim, spacedim> &dof_handler);
 
  void
  declare_data_vector(const std::string &name, const VectorType vector_type);
 
  void
  declare_data_vector(const std::vector<std::string> &name,
                      const VectorType                vector_type);
 
 
  template <typename number>
  void
  add_data_vector(const Vector<number> &vec, const std::string &name);
 
  template <typename number>
  void
  add_data_vector(const Vector<number> &          vec,
                  const std::vector<std::string> &names);
 
  void
  build_patches(const unsigned int n_subdivisions = 0);
 
  void
  finish_parameter_value();
 
  std::size_t
  memory_consumption() const;
 
  DeclException1(
    ExcVectorNotDeclared,
    std::string,
    << "The data vector for which the first component has the name " << arg1
    << " has not been added before.");
  DeclExceptionMsg(ExcDataNotCleared,
                   "You cannot start a new time/parameter step before calling "
                   "finish_parameter_value() on the previous step.");
  DeclExceptionMsg(
    ExcDataAlreadyAdded,
    "You cannot declare additional vectors after already calling "
    "build_patches(). All data vectors need to be declared "
    "before you call this function the first time.");
  DeclException1(ExcNameAlreadyUsed,
                 std::string,
                 << "You tried to declare a component of a data vector with "
                 << "the name <" << arg1
                 << ">, but that name is already used.");
 
private:
  double parameter;
 
  double parameter_step;
 
  SmartPointer<const DoFHandler<dim, spacedim>,
               DataOutStack<dim, spacedim, void>>
    dof_handler;
 
  std::vector<::DataOutBase::Patch<patch_dim, patch_spacedim>> patches;
 
  struct DataVector
  {
    Vector<double> data;
 
    std::vector<std::string> names;
 
    std::size_t
    memory_consumption() const;
  };
 
  std::vector<DataVector> dof_data;
 
  std::vector<DataVector> cell_data;
 
  virtual const std::vector<::DataOutBase::Patch<
    DataOutStack<dim, spacedim, void>::patch_dim,
    DataOutStack<dim, spacedim, void>::patch_spacedim>> &
  get_patches() const override;
 
 
  virtual std::vector<std::string>
  get_dataset_names() const override;
};
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif