vector_selector.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2009 - 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__mesh_worker_vector_selector_h
#define dealii__mesh_worker_vector_selector_h

#include <deal.II/algorithms/any_data.h>
#include <deal.II/algorithms/named_selection.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/smartpointer.h>
#include <deal.II/base/mg_level_object.h>

DEAL_II_NAMESPACE_OPEN

template<int,int> class FEValuesBase;

namespace MeshWorker
{

  class VectorSelector :
    public Subscriptor
  {
  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 <class StreamType, typename DATA>
    void print (StreamType &s, const AnyData &v) const;

    template <class 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();

    VectorDataBase(const VectorSelector &);

    void initialize(const AnyData &);

    virtual ~VectorDataBase();

    virtual void fill(
      std::vector<std::vector<std::vector<Number> > > &values,
      std::vector<std::vector<std::vector<Tensor<1,dim,Number> > > > &gradients,
      std::vector<std::vector<std::vector<Tensor<2,dim,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,dim,Number> > > > &gradients,
      std::vector<std::vector<std::vector<Tensor<2,dim,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;

    std::size_t memory_consumption () const;
  protected:
    AnyData data;
  };


  template <typename VectorType, int dim, int spacedim = dim>
  class VectorData :
    public VectorDataBase<dim, spacedim,typename VectorType::value_type>
  {
  public:
    VectorData();
    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,dim,typename VectorType::value_type> > > > &gradients,
      std::vector<std::vector<std::vector<Tensor<2,dim,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;

    virtual void mg_fill(
      std::vector<std::vector<std::vector<typename VectorType::value_type> > > &values,
      std::vector<std::vector<std::vector<Tensor<1,dim,typename VectorType::value_type> > > > &gradients,
      std::vector<std::vector<std::vector<Tensor<2,dim,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;

    std::size_t memory_consumption () const;
  };


  template <typename VectorType, int dim, int spacedim = dim>
  class MGVectorData :
    public VectorData<VectorType, dim, spacedim>
  {
  public:
    MGVectorData();

    MGVectorData(const VectorSelector &);

    void initialize(const AnyData &);

    void initialize(const MGLevelObject<VectorType> *, const std::string &name);


    std::size_t memory_consumption () const;
  };


//----------------------------------------------------------------------//

  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 <class StreamType>
  inline void
  VectorSelector::print(StreamType &s) const
  {
    s << "values: " << n_values()
      << " gradients: " << n_gradients()
      << " hessians: " << n_hessians()
      << std::endl;
  }


  template <class 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);
  }
}


DEAL_II_NAMESPACE_CLOSE

#endif