splitter.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/base_header.hpp>
#include <kernel/lafem/base.hpp>
#include <kernel/global/gate.hpp>
#include <kernel/global/muxer.hpp>
#include <kernel/global/vector.hpp>
 
namespace FEAT
{
  namespace Global
  {
    template<typename LocalVector_, typename Mirror_>
    class Splitter
    {
    public:
      typedef Global::Muxer<LocalVector_, Mirror_> MuxerType;
 
      typedef LocalVector_ LocalVectorType;
 
      typedef Mirror_ MirrorType;
 
      typedef Global::Vector<LocalVector_, Mirror_> GlobalVectorType;
 
    public:
      MuxerType _muxer;
      LocalVector_ _base_vector_tmpl;
 
    public:
      Splitter() :
        _muxer(),
        _base_vector_tmpl()
      {
      }
 
      Splitter(Splitter&& other) :
        _muxer(std::forward<MuxerType>(other._muxer)),
        _base_vector_tmpl(std::forward<LocalVector_>(other._base_vector_tmpl))
      {
      }
 
      explicit Splitter(MuxerType&& muxer, LocalVector_&& base_vector_tmpl) :
        _muxer(std::forward<MuxerType>(muxer)),
        _base_vector_tmpl(std::forward<LocalVector_>(base_vector_tmpl))
      {
      }
 
      virtual ~Splitter()
      {
      }
 
      Splitter& operator=(Splitter&& other)
      {
        if(this == &other)
          return *this;
 
        _muxer = std::forward<MuxerType>(other._muxer);
        _base_vector_tmpl = std::forward<LocalVector_>(other._base_vector_tmpl);
 
        return *this;
      }
 
      template<typename LVT2_, typename MT2_>
      void convert(const Splitter<LVT2_, MT2_>& other)
      {
        if((void*)this == (void*)&other)
          return;
 
        this->_muxer.convert(other._muxer);
        this->_base_vector_tmpl.convert(other._base_vector_tmpl);
      }
 
      template<typename LVT2_>
      void convert(const Splitter<LVT2_, Mirror_>& other, LocalVector_&& vector, LAFEM::CloneMode mode = LAFEM::CloneMode::Shallow)
      {
        if((void*)this == (void*)&other)
          return;
 
        this->_muxer.convert(other._muxer, std::forward<LocalVector_>(vector), mode);
        this->_base_vector_tmpl.clear(); // needs to be supplied later
      }
 
      std::size_t bytes() const
      {
        return _muxer.bytes() + _base_vector_tmpl.bytes();
      }
 
      bool is_root() const
      {
        return (_muxer.get_sibling_comm() == nullptr) || _muxer.is_parent();
      }
 
      bool is_single() const
      {
        return (_muxer.get_sibling_comm() == nullptr) || (_muxer.get_sibling_comm()->size() == 1);
      }
 
      void set_root(const Dist::Comm* comm, int root_rank, Mirror_&& root_mirror)
      {
        this->_muxer.set_parent(comm, root_rank, std::forward<Mirror_>(root_mirror));
      }
 
      void push_patch(Mirror_&& patch_mirror)
      {
        _muxer.push_child(std::forward<Mirror_>(patch_mirror));
      }
 
      void set_base_vector_template(LocalVector_&& vector_template)
      {
        _base_vector_tmpl = std::forward<LocalVector_>(vector_template);
      }
 
      const LocalVector_& get_base_vector_template() const
      {
        return _base_vector_tmpl;
      }
 
      const MuxerType& get_muxer() const
      {
        return _muxer;
      }
 
      void compile(const LocalVector_& vec_tmp_)
      {
        _muxer.compile(vec_tmp_);
      }
 
      LocalVector_ create_base_vector() const
      {
        XASSERT(!this->_base_vector_tmpl.empty());
        return this->_base_vector_tmpl.clone(LAFEM::CloneMode::Layout);
      }
 
      LocalVector_ join(const Global::Vector<LocalVector_, Mirror_>& vector) const
      {
        // are there no other processes involved here?
        if(is_single())
          return vector.local().clone();
 
        // make sure the root rank has a base-vector template
        if(is_root())
        {
          XASSERTM(_base_vector_tmpl.size() > Index(0), "root process must have a base vector template");
        }
 
        // create an base-mesh vector (may be empty on all processes except for parent)
        LocalVector_ vec_base(this->_base_vector_tmpl.clone(LAFEM::CloneMode::Layout));
 
        // actual join
        join(vec_base, vector);
 
        // return local vector
        return vec_base;
      }
 
      void join(LocalVector_& vec_base, const Global::Vector<LocalVector_, Mirror_>& vector) const
      {
        // are there no other processes involved here?
        if(is_single())
        {
          vec_base.copy(vector.local());
          return;
        }
 
        // Note: the 'join' of the muxer class works with type-0 vectors, so we need to create a
        // temporary type-0 conversion of our input vector here, which is assumed to be a type-1
        // vector. In theory, we also should apply a 'sync_0' on the returned vector, but since
        // its a 'local' vector on the whole base-mesh domain, it is redundant and it also does
        // not make sense due to the lack of a gate on the base-mesh, i.e. on the base-mesh
        // type-0 and type-1 are the same thing.
 
        // convert input vector to type 0
        GlobalVectorType vector_0 = vector.clone(LAFEM::CloneMode::Deep);
        vector_0.from_1_to_0();
 
        // is this the muxer parent or only a child process?
        if(_muxer.is_parent())
        {
          _muxer.join(vector_0.local(), vec_base);
        }
        else
        {
          XASSERT(_muxer.is_child());
          _muxer.join_send(vector_0.local());
        }
      }
 
      void split(Global::Vector<LocalVector_, Mirror_>& vector, const LocalVector_& vec_base) const
      {
        // call patch-local version
        split(vector.local(), vec_base);
      }
 
      void split(LocalVector_& vector, const LocalVector_& vec_base) const
      {
        // are there no other processes involved here?
        if(is_single())
        {
          // simply copy the local vector contents
          vector.copy(vec_base);
          return;
        }
 
        // do we have a base muxer?
        if(_muxer.is_parent())
        {
          _muxer.split(vector, vec_base);
        }
        else
        {
          XASSERT(_muxer.is_child());
          _muxer.split_recv(vector);
        }
      }
 
      void join_write_out(const Global::Vector<LocalVector_, Mirror_>& vector, const String& filename,
        LAFEM::FileMode mode = LAFEM::FileMode::fm_binary) const
      {
        // actual join
        LocalVector_ vec_base(join(vector));
 
        // if we're the parent (rank 0), then we do the actual write out
        if(this->is_root())
        {
          vec_base.write_out(mode, filename);
        }
      }
 
      void split_read_from(Global::Vector<LocalVector_, Mirror_>& vector, const String& filename,
        LAFEM::FileMode mode = LAFEM::FileMode::fm_binary) const
      {
        split_read_from(vector.local(), filename, mode);
      }
 
      void split_read_from(LocalVector_& vector, const String& filename,
        LAFEM::FileMode mode = LAFEM::FileMode::fm_binary) const
      {
        // create an empty base-mesh vector
        LocalVector_ vec_base;
 
        // if we're the parent (rank 0), then we do the actual read from
        if(this->is_root())
        {
          // read the actual vector
          vec_base.read_from(mode, filename);
        }
 
        // split the vector
        split(vector, vec_base);
      }
    }; // class Splitter<...>
  } // namespace Global
} // namespace FEAT