power_mirror.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
#include <kernel/lafem/power_vector.hpp>
#include <kernel/lafem/vector_mirror.hpp>
 
namespace FEAT
{
  namespace LAFEM
  {
    namespace Intern
    {
      // PowerMirror helper class: this implements the actual recursion for the gather/scatter methods
      template<int i_>
      struct PowerMirrorHelper
      {
        template<typename SM_, typename BV_, typename PV_>
        static void gather(const SM_& sm, BV_& bv, const PV_& pv, const Index bo)
        {
          sm.gather(bv, pv.first(), bo);
          PowerMirrorHelper<i_-1>::gather(sm, bv, pv.rest(), bo + sm.buffer_size(pv.first()));
        }
        template<typename SM_, typename PV_, typename BV_, typename AT_>
        static void scatter_axpy(const SM_& sm, PV_& pv, const BV_& bv, const AT_ a, const Index bo)
        {
          sm.scatter_axpy(pv.first(), bv, a, bo);
          PowerMirrorHelper<i_-1>::scatter_axpy(sm, pv.rest(), bv, a, bo + sm.buffer_size(pv.first()));
        }
        template<typename SM_, typename PV_>
        static Index buffer_size(const SM_& sm, PV_& pv)
        {
          return sm.buffer_size(pv.first()) + PowerMirrorHelper<i_-1>::buffer_size(sm, pv.rest());
        }
        template<Perspective perspective_, typename SM_, typename Pv_>
        static Index mask_scatter(const SM_& sm, const Pv_& pv, std::vector<int>& mask, const int value, const Index offset)
        {
          Index nf = sm.template mask_scatter<perspective_>(pv.first(), mask, value, offset);
          Index nr = PowerMirrorHelper<i_-1>::template mask_scatter<perspective_>(sm, pv.rest(), mask, value, offset + nf);
          return nf + nr;
        }
      };
 
      template<>
      struct PowerMirrorHelper<1>
      {
        template<typename SM_, typename BV_, typename PV_>
        static void gather(const SM_& sm, BV_& bv, const PV_& pv, const Index bo)
        {
          sm.gather(bv, pv.first(), bo);
        }
        template<typename SM_, typename PV_, typename BV_, typename AT_>
        static void scatter_axpy(const SM_& sm, PV_& pv, const BV_& bv, const AT_ a, const Index bo)
        {
          sm.scatter_axpy(pv.first(), bv, a, bo);
        }
        template<typename SM_, typename PV_>
        static Index buffer_size(const SM_& sm, PV_& pv)
        {
          return sm.buffer_size(pv.first());
        }
        template<Perspective perspective_, typename SM_, typename Pv_>
        static Index mask_scatter(const SM_& sm, const Pv_& pv, std::vector<int>& mask, const int value, const Index offset)
        {
          return sm.template mask_scatter<perspective_>(pv.first(), mask, value, offset);
        }
      };
    } // namespace Intern
 
    template<typename SubMirror_, int count_>
    class PowerMirror
    {
    public:
      static_assert(count_ > 0, "invalid block size");
 
      typedef SubMirror_ SubMirrorType;
      typedef typename SubMirrorType::DataType DataType;
      typedef typename SubMirrorType::IndexType IndexType;
 
      static constexpr int num_blocks = count_;
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using MirrorType = PowerMirror<typename SubMirrorType::template MirrorType<DT2_, IT2_>, count_>;
 
      template <typename DataType2_, typename IndexType2_>
      using MirrorTypeByDI = MirrorType<DataType2_, IndexType2_>;
 
      SubMirrorType _sub_mirror;
 
      PowerMirror()
      {
      }
 
      explicit PowerMirror(SubMirrorType&& sub_mirror) :
        _sub_mirror(std::move(sub_mirror))
      {
      }
 
      PowerMirror(PowerMirror&& other) :
        _sub_mirror(std::move(other._sub_mirror))
      {
      }
 
      PowerMirror& operator=(PowerMirror&& other)
      {
        if(this != &other)
        {
          _sub_mirror = std::move(other._sub_mirror);
        }
        return *this;
      }
 
      PowerMirror clone(CloneMode clone_mode = CloneMode::Weak) const
      {
        return PowerMirror(_sub_mirror.clone(clone_mode));
      }
 
      template<typename SubMirror2_>
      void convert(const PowerMirror<SubMirror2_, count_>& other)
      {
        this->_sub_mirror.convert(other._sub_mirror);
      }
 
      template<typename SubVector_>
      static PowerMirror make_empty(const PowerVector<SubVector_, count_>& tmpl_vec)
      {
        return PowerMirror(SubMirrorType::make_empty(tmpl_vec.first()));
      }
 
      std::size_t bytes() const
      {
        return _sub_mirror.bytes();
      }
 
      bool empty() const
      {
        return this->_sub_mirror.empty();
      }
 
      template<typename SubVector_>
      Index buffer_size(const PowerVector<SubVector_, count_>& vector) const
      {
        return Intern::PowerMirrorHelper<count_>::buffer_size(_sub_mirror, vector);
      }
 
      template<typename SubVector_>
      DenseVector<DataType, IndexType> create_buffer(const PowerVector<SubVector_, count_>& vector) const
      {
        return DenseVector<DataType, IndexType>(buffer_size(vector));
      }
 
      template<int i_>
      SubMirrorType& at()
      {
        static_assert((0 <= i_) && (i_ < count_), "invalid sub-mirror index");
        return _sub_mirror;
      }
 
      template<int i_>
      const SubMirrorType& at() const
      {
        static_assert((0 <= i_) && (i_ < count_), "invalid sub-mirror index");
        return _sub_mirror;
      }
 
      SubMirrorType& get(int i)
      {
        XASSERTM((0 <= i) && (i < count_), "invalid sub-mirror index");
        return _sub_mirror;
      }
 
      const SubMirrorType& get(int i) const
      {
        XASSERTM((0 <= i) && (i < count_), "invalid sub-mirror index");
        return _sub_mirror;
      }
 
      template<typename Tv_>
      void gather(
        LAFEM::DenseVector<DataType, IndexType>& buffer,
        const LAFEM::PowerVector<Tv_, count_>& vector,
        const Index buffer_offset = Index(0)) const
      {
        Intern::PowerMirrorHelper<count_>::gather(_sub_mirror, buffer, vector, buffer_offset);
      }
 
      template<typename Tv_>
      void scatter_axpy(
        LAFEM::PowerVector<Tv_, count_>& vector,
        const LAFEM::DenseVector<DataType, IndexType>& buffer,
        const DataType alpha = DataType(1),
        const Index buffer_offset = Index(0)) const
      {
        Intern::PowerMirrorHelper<count_>::scatter_axpy(_sub_mirror, vector, buffer, alpha, buffer_offset);
      }
 
      template<Perspective perspective_, typename Tv_>
      Index mask_scatter(const LAFEM::PowerVector<Tv_, count_>& vector, std::vector<int>& mask,
        const int value, const Index offset = Index(0)) const
      {
        return Intern::PowerMirrorHelper<count_>::template mask_scatter<perspective_>(_sub_mirror, vector, mask, value, offset);
      }
 
    }; // class PowerMirror<...>
  } // namespace LAFEM
} // namespace FEAT