vector_selector.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2009 - 2024 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_mesh_worker_vector_selector_h
#define dealii_mesh_worker_vector_selector_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/algorithms/any_data.h>
#include <deal.II/algorithms/named_selection.h>
 
#include <deal.II/base/mg_level_object.h>
#include <deal.II/base/observer_pointer.h>
#include <deal.II/base/tensor.h>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declaration
#ifndef DOXYGEN
template <int, int>
class FEValuesBase;
#endif
 
namespace MeshWorker
{
  class VectorSelector : public EnableObserverPointer
  {
  public:
    void
    add(const std::string &name,
        const bool         values    = true,
        const bool         gradients = false,
        const bool         hessians  = false);
 
    //      void add(const std::string& name,
    //               const unsigned int selected_block,
    //             bool values = true,
    //             bool gradients = false,
    //             bool hessians = false);
 
    void
    initialize(const AnyData &);
 
    bool
    empty() const;
 
    bool
    has_values() const;
 
    bool
    has_gradients() const;
 
    bool
    has_hessians() const;
 
    unsigned int
    n_values() const;
 
    unsigned int
    n_gradients() const;
 
    unsigned int
    n_hessians() const;
 
    unsigned int
    value_index(const unsigned int i) const;
 
    unsigned int
    gradient_index(const unsigned int i) const;
 
    unsigned int
    hessian_index(const unsigned int i) const;
 
    template <typename StreamType, typename DATA>
    void
    print(StreamType &s, const AnyData &v) const;
 
    template <typename StreamType>
    void
    print(StreamType &s) const;
 
    std::size_t
    memory_consumption() const;
 
  protected:
    NamedSelection value_selection;
 
    NamedSelection gradient_selection;
 
    NamedSelection hessian_selection;
  };
 
  template <int dim, int spacedim = dim, typename Number = double>
  class VectorDataBase : public VectorSelector
  {
  public:
    VectorDataBase() = default;
 
    VectorDataBase(const VectorSelector &);
 
    void
    initialize(const AnyData &);
 
    virtual ~VectorDataBase() override = default;
 
    virtual void
    fill(std::vector<std::vector<std::vector<Number>>> &values,
         std::vector<std::vector<std::vector<Tensor<1, spacedim, Number>>>>
           &gradients,
         std::vector<std::vector<std::vector<Tensor<2, spacedim, Number>>>>
                                                    &hessians,
         const FEValuesBase<dim, spacedim>          &fe,
         const std::vector<types::global_dof_index> &index,
         const unsigned int                          component,
         const unsigned int                          n_comp,
         const unsigned int                          start,
         const unsigned int                          size) const;
 
    virtual void
    mg_fill(std::vector<std::vector<std::vector<Number>>> &values,
            std::vector<std::vector<std::vector<Tensor<1, spacedim, Number>>>>
              &gradients,
            std::vector<std::vector<std::vector<Tensor<2, spacedim, Number>>>>
                                                       &hessians,
            const FEValuesBase<dim, spacedim>          &fe,
            const unsigned int                          level,
            const std::vector<types::global_dof_index> &index,
            const unsigned int                          component,
            const unsigned int                          n_comp,
            const unsigned int                          start,
            const unsigned int                          size) const;
 
  protected:
    AnyData data;
  };
 
 
  template <typename VectorType, int dim, int spacedim = dim>
  class VectorData
    : public VectorDataBase<dim, spacedim, typename VectorType::value_type>
  {
  public:
    VectorData() = default;
 
    VectorData(const VectorSelector &);
 
    void
    initialize(const AnyData &);
 
    void
    initialize(const VectorType *, const std::string &name);
 
    virtual void
    fill(std::vector<std::vector<std::vector<typename VectorType::value_type>>>
           &values,
         std::vector<std::vector<
           std::vector<Tensor<1, spacedim, typename VectorType::value_type>>>>
           &gradients,
         std::vector<std::vector<
           std::vector<Tensor<2, spacedim, typename VectorType::value_type>>>>
                                                    &hessians,
         const FEValuesBase<dim, spacedim>          &fe,
         const std::vector<types::global_dof_index> &index,
         const unsigned int                          component,
         const unsigned int                          n_comp,
         const unsigned int                          start,
         const unsigned int                          size) const override;
 
    virtual void
    mg_fill(
      std::vector<std::vector<std::vector<typename VectorType::value_type>>>
        &values,
      std::vector<std::vector<
        std::vector<Tensor<1, spacedim, typename VectorType::value_type>>>>
        &gradients,
      std::vector<std::vector<
        std::vector<Tensor<2, spacedim, typename VectorType::value_type>>>>
                                                 &hessians,
      const FEValuesBase<dim, spacedim>          &fe,
      const unsigned int                          level,
      const std::vector<types::global_dof_index> &index,
      const unsigned int                          component,
      const unsigned int                          n_comp,
      const unsigned int                          start,
      const unsigned int                          size) const override;
 
    std::size_t
    memory_consumption() const;
  };
 
 
  template <typename VectorType, int dim, int spacedim = dim>
  class MGVectorData : public VectorData<VectorType, dim, spacedim>
  {
  public:
    MGVectorData() = default;
 
    MGVectorData(const VectorSelector &);
 
    void
    initialize(const AnyData &);
 
    void
    initialize(const MGLevelObject<VectorType> *, const std::string &name);
  };
 
 
  //----------------------------------------------------------------------//
 
  inline void
  VectorSelector::add(const std::string &name,
                      const bool         values,
                      const bool         gradients,
                      const bool         hessians)
  {
    if (values)
      value_selection.add(name);
    if (gradients)
      gradient_selection.add(name);
    if (hessians)
      hessian_selection.add(name);
  }
 
 
  // inline void
  // VectorSelector::add(const std::string& name,
  //   const unsigned int block,
  //   bool values, bool gradients, bool hessians)
  //{
  //  if (values) value_selection.add(name, block);
  //  if (gradients) gradient_selection.add(name, block);
  //  if (hessians) hessian_selection.add(name, block);
  //}
 
 
  inline void
  VectorSelector::initialize(const AnyData &src)
  {
    value_selection.initialize(src);
    gradient_selection.initialize(src);
    hessian_selection.initialize(src);
  }
 
  inline bool
  VectorSelector::empty() const
  {
    return (value_selection.size() == 0 && gradient_selection.size() == 0 &&
            hessian_selection.size() == 0);
  }
 
 
  inline bool
  VectorSelector::has_values() const
  {
    return value_selection.size() != 0;
  }
 
 
  inline bool
  VectorSelector::has_gradients() const
  {
    return gradient_selection.size() != 0;
  }
 
 
  inline bool
  VectorSelector::has_hessians() const
  {
    return hessian_selection.size() != 0;
  }
 
 
  inline unsigned int
  VectorSelector::n_values() const
  {
    return value_selection.size();
  }
 
 
  inline unsigned int
  VectorSelector::n_gradients() const
  {
    return gradient_selection.size();
  }
 
 
  inline unsigned int
  VectorSelector::n_hessians() const
  {
    return hessian_selection.size();
  }
 
 
  inline unsigned int
  VectorSelector::value_index(const unsigned int i) const
  {
    return value_selection(i);
  }
 
 
  inline unsigned int
  VectorSelector::gradient_index(const unsigned int i) const
  {
    return gradient_selection(i);
  }
 
 
  inline unsigned int
  VectorSelector::hessian_index(const unsigned int i) const
  {
    return hessian_selection(i);
  }
 
 
  template <typename StreamType>
  inline void
  VectorSelector::print(StreamType &s) const
  {
    s << "values: " << n_values() << " gradients: " << n_gradients()
      << " hessians: " << n_hessians() << std::endl;
  }
 
 
  template <typename StreamType, typename DATA>
  inline void
  VectorSelector::print(StreamType &s, const AnyData &v) const
  {
    s << "values:   ";
    for (unsigned int i = 0; i < n_values(); ++i)
      s << " '" << v.name(value_selection(i)) << '\'';
    s << std::endl << "gradients:";
    for (unsigned int i = 0; i < n_gradients(); ++i)
      s << " '" << v.name(gradient_selection(i)) << '\'';
    s << std::endl << "hessians: ";
    for (unsigned int i = 0; i < n_hessians(); ++i)
      s << " '" << v.name(hessian_selection(i)) << '\'';
    s << std::endl;
  }
 
 
  inline std::size_t
  VectorSelector::memory_consumption() const
  {
    return sizeof(*this);
  }
} // namespace MeshWorker
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif