localvector.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_PDELAB_GRIDFUNCTIONSPACE_LOCALVECTOR_HH
#define DUNE_PDELAB_GRIDFUNCTIONSPACE_LOCALVECTOR_HH
 
#include <vector>
#include <algorithm>
#include <functional>
#include <numeric>
#include <dune/pdelab/gridfunctionspace/localfunctionspacetags.hh>
 
namespace Dune {
  namespace PDELab {
 
    template<typename C>
    class WeightedVectorAccumulationView
    {
    public:
 
      typedef C Container;
 
      typedef typename Container::BaseContainer BaseContainer;
 
      typedef typename Container::value_type value_type;
 
      typedef typename Container::weight_type weight_type;
 
      typedef WeightedVectorAccumulationView WeightedAccumulationView;
 
      WeightedAccumulationView weightedAccumulationView(weight_type weight)
      {
        return WeightedAccumulationView(container(),weight*this->weight());
      }
 
      typedef typename Container::size_type size_type;
 
 
      weight_type weight() const
      {
        return _weight;
      }
 
 
      void setWeight(weight_type weight)
      {
        _weight = weight;
      }
 
      template<typename LFS>
      void accumulate(const LFS& lfs, size_type n, value_type v)
      {
        _modified = true;
        _container(lfs,n) += _weight * v;
      }
 
 
      template<typename LFS>
      void rawAccumulate(const LFS& lfs, size_type n, value_type v)
      {
        _modified = true;
        _container(lfs,n) += v;
      }
 
      WeightedVectorAccumulationView(C& container, weight_type weight)
        : _container(container)
        , _weight(weight)
        , _modified(false)
      {}
 
      size_type size() const
      {
        return _container.size();
      }
 
      bool modified() const
      {
        return _modified;
      }
 
 
      void resetModified()
      {
        _modified = false;
      }
 
      Container& container()
      {
        _modified = true;
        return _container;
      }
 
      const Container& container() const
      {
        return _container;
      }
 
      BaseContainer& base()
      {
        _modified = true;
        return _container.base();
      }
 
      const BaseContainer& base() const
      {
        return _container.base();
      }
 
      auto data()
      {
        return _container.data();
      }
 
      const auto data() const
      {
        return _container.data();
      }
 
    private:
      C& _container;
      weight_type _weight;
      bool _modified;
    };
 
 
 
    template<typename T, typename LFSFlavorTag = AnySpaceTag, typename W = T>
    class LocalVector
    {
    public:
 
      typedef std::vector<T> BaseContainer;
 
      typedef typename BaseContainer::value_type  value_type;
      typedef value_type field_type;
 
      typedef typename BaseContainer::size_type    size_type;
 
      typedef typename BaseContainer::reference    reference;
 
      typedef typename BaseContainer::const_reference const_reference;
 
 
      typedef W weight_type;
 
      typedef WeightedVectorAccumulationView<LocalVector> WeightedAccumulationView;
 
      WeightedAccumulationView weightedAccumulationView(weight_type weight)
      {
        return WeightedAccumulationView(*this,weight);
      }
 
 
      template<typename LFS>
      reference operator()(const LFS& lfs, size_type i)
      {
        return _container[lfs.localIndex(i)];
      }
 
 
      template<typename LFS>
      const_reference operator()(const LFS& lfs, size_type i) const
      {
        return _container[lfs.localIndex(i)];
      }
 
      auto data()
      {
        return _container.data();
      }
 
      const auto data() const
      {
        return _container.data();
      }
 
      LocalVector& axpy(const value_type alpha, const LocalVector& other)
      {
        std::transform(_container.begin(),_container.end(),
                       other._container.begin(),
                       _container.begin(),
                       [=](const value_type &a,
                           const value_type &b) { return a + alpha*b;});
        return *this;
      }
 
      LocalVector& operator=(const value_type& v)
      {
        std::fill(_container.begin(),_container.end(),v);
        return *this;
      }
 
      LocalVector& operator+=(const LocalVector& other)
      {
        std::transform(_container.begin(),_container.end(),
                       other._container.begin(),
                       _container.begin(),
                       std::plus<value_type>());
        return *this;
      }
 
      LocalVector& operator*=(const value_type& v)
      {
        using namespace std::placeholders;
        std::transform(
          _container.begin(),
          _container.end(),
          _container.begin(),
          std::bind(std::multiplies<value_type>(),v,_1)
          );
        return *this;
      }
 
      value_type dot(const LocalVector& other) const
      {
        value_type dot_product=0.0;
        dot_product = std::inner_product(_container.begin(),_container.end(),
                                         other._container.begin(),
                                         dot_product);
        return dot_product;
      }
 
      value_type two_norm() const
      {
        value_type nrm=0.0;
        nrm = std::inner_product(_container.begin(),_container.end(),
                                 _container.begin(),
                                 nrm);
        return sqrt(nrm);
      }
 
      size_type size() const
      {
        return _container.size();
      }
 
      void resize(size_type size)
      {
        _container.resize(size);
      }
 
      void assign(size_type size, const T& value)
      {
        _container.assign(size,value);
      }
 
      BaseContainer& base()
      {
        return _container;
      }
 
      const BaseContainer& base() const
      {
        return _container;
      }
 
      LocalVector()
      {}
 
      explicit LocalVector(size_type n)
        : _container(n)
      {}
 
      LocalVector(size_type n, const value_type & v)
        : _container(n,v)
      {}
 
    private:
 
      BaseContainer _container;
 
    };
 
 
    template<typename C>
    C& accessBaseContainer(C& c)
    {
      return c;
    }
 
    template<typename T, typename Tag, typename W>
    typename LocalVector<T,Tag,W>::BaseContainer& accessBaseContainer(LocalVector<T,Tag,W>& c)
    {
      return c.base();
    }
 
    template<typename C>
    typename WeightedVectorAccumulationView<C>::BaseContainer& accessBaseContainer
    (WeightedVectorAccumulationView<C>& c)
    {
      return c.base();
    }
 
    template<typename C>
    const C& accessBaseContainer(const C& c)
    {
      return c;
    }
 
    template<typename T, typename Tag, typename W>
    const typename LocalVector<T,Tag,W>::BaseContainer& accessBaseContainer(const LocalVector<T,Tag,W>& c)
    {
      return c.base();
    }
 
    template<typename C>
    const typename WeightedVectorAccumulationView<C>::BaseContainer& accessBaseContainer
    (const WeightedVectorAccumulationView<C>& c)
    {
      return c.base();
    }
 
  } // end namespace PDELab
} // end namespace Dune
 
#endif // DUNE_PDELAB_GRIDFUNCTIONSPACE_LOCALVECTOR_HH