vector.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/global/gate.hpp>
#include <kernel/util/math.hpp>
#include <kernel/lafem/container.hpp> // required for LAFEM::CloneMode
 
namespace FEAT
{
  namespace Global
  {
    template<typename LocalVector_, typename Mirror_>
    class Vector
    {
    public:
      typedef Gate<LocalVector_, Mirror_> GateType;
 
      typedef typename LocalVector_::DataType DataType;
      typedef typename LocalVector_::IndexType IndexType;
      typedef LocalVector_ LocalVectorType;
 
      template <typename LocalVector2_, typename Mirror2_ = Mirror_>
      using ContainerType = Vector<LocalVector2_, Mirror2_>;
 
      template <typename DataType2_, typename IndexType2_>
      using ContainerTypeByMDI = Vector<
        typename LocalVector_::template ContainerType<DataType2_, IndexType2_>,
        typename Mirror_::template MirrorType<DataType2_, IndexType2_> >;
 
    protected:
      const GateType* _gate;
      LocalVector_ _vector;
 
    public:
      Vector() :
        _gate(nullptr),
        _vector()
      {
      }
 
      template<typename... Args_>
      explicit Vector(const GateType* gate, Args_&&... args) :
        _gate(gate),
        _vector(std::forward<Args_>(args)...)
      {
      }
 
      LocalVector_& local()
      {
        return _vector;
      }
 
      const LocalVector_& local() const
      {
        return _vector;
      }
 
      template<typename OtherGlobalVector_>
      void convert(const GateType* gate, const OtherGlobalVector_ & other)
      {
        this->_gate = gate;
        this->_vector.convert(other.local());
      }
 
      const GateType* get_gate() const
      {
        return _gate;
      }
 
      const Dist::Comm* get_comm() const
      {
        return (_gate != nullptr ? _gate->get_comm() : nullptr);
      }
 
      void from_1_to_0()
      {
        ASSERTM(_gate, "Gate is not set!");
        _gate->from_1_to_0(this->_vector);
      }
 
      void sync_0()
      {
        ASSERTM(_gate, "Gate is not set!");
        _gate->sync_0(_vector);
      }
 
      auto sync_0_async() -> decltype(_gate->sync_0_async(_vector))
      //decltype(_gate->sync_0(_vector)) sync_0_async()
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->sync_0_async(_vector);
      }
 
      void sync_1()
      {
        ASSERTM(_gate, "Gate is not set!");
        _gate->sync_1(_vector);
      }
 
      auto sync_1_async() -> decltype(_gate->sync_1_async(_vector))
      //decltype(_gate->sync_1(_vector)) sync_1_async()
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->sync_1_async(_vector);
      }
 
      template<LAFEM::Perspective perspective_ = LAFEM::Perspective::pod>
      Index size() const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->template get_num_global_dofs<perspective_>();
      }
 
      Vector clone(LAFEM::CloneMode mode = LAFEM::CloneMode::Weak) const
      {
        return Vector(_gate, _vector.clone(mode));
      }
 
      void clone(const Vector& other, LAFEM::CloneMode mode = LAFEM::CloneMode::Weak)
      {
        XASSERTM(&(other.local()) != &(this->local()), "Trying to self-clone a Global::Vector!");
        *this = other.clone(mode);
      }
 
      void clear()
      {
        _vector.clear();
      }
 
      void format(DataType alpha = DataType(0))
      {
        _vector.format(alpha);
      }
 
      void format(Random & rng, DataType min, DataType max)
      {
        _vector.format(rng, min, max);
        sync_1();
      }
 
      void copy(const Vector& x)
      {
        // avoid self-copy
        if(this != &x)
        {
          _vector.copy(x.local());
        }
      }
 
      void axpy(const Vector& x, const DataType alpha = DataType(1))
      {
        _vector.axpy(x.local(), alpha);
      }
 
      void scale(const Vector& x, const DataType alpha)
      {
        _vector.scale(x.local(), alpha);
      }
 
      DataType dot(const Vector& x) const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->dot(_vector, x.local());
      }
 
      SynchScalarTicket<DataType> dot_async(const Vector& x) const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->dot_async(_vector, x.local());
      }
 
      DataType norm2sqr() const
      {
        return dot(*this);
      }
 
      SynchScalarTicket<DataType> norm2sqr_async() const
      {
        return dot_async(*this);
      }
 
      DataType norm2() const
      {
        return Math::sqrt(norm2sqr());
      }
 
      SynchScalarTicket<DataType> norm2_async() const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->dot_async(_vector, _vector, true);
      }
 
      void component_invert(const Vector& x, const DataType alpha = DataType(1))
      {
        _vector.component_invert(x.local(), alpha);
      }
 
      void component_product(const Vector& x, const Vector& y)
      {
        _vector.component_product(x.local(), y.local());
      }
 
      DataType max_abs_element() const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->max(_vector.max_abs_element());
      }
 
      SynchScalarTicket<DataType> max_abs_element_async() const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->max_async(_vector.max_abs_element());
      }
 
      DataType min_abs_element() const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->min(_vector.min_abs_element());
      }
 
      SynchScalarTicket<DataType> min_abs_element_async() const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->min_async(_vector.min_abs_element());
      }
 
      DataType max_element() const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->max_async(_vector.max_element());
      }
 
      SynchScalarTicket<DataType> max_element_async() const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->max_async(_vector.max_element());
      }
 
      DataType min_element() const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->min(_vector.min_element());
      }
 
      SynchScalarTicket<DataType> min_element_async() const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->min_async(_vector.min_element());
      }
 
      DataType max_rel_diff(const Vector & x) const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->max(_vector.max_rel_diff(x));
      }
 
      SynchScalarTicket<DataType> max_rel_diff_async(const Vector & x) const
      {
        ASSERTM(_gate, "Gate is not set!");
        return _gate->max_async(_vector.max_rel_diff(x));
      }
 
 
      std::uint64_t get_checkpoint_size(LAFEM::SerialConfig& config)
      {
        return _vector.get_checkpoint_size(config);
      }
 
      void restore_from_checkpoint_data(std::vector<char>& data)
      {
        _vector.restore_from_checkpoint_data(data);
      }
 
      std::uint64_t set_checkpoint_data(std::vector<char>& data, LAFEM::SerialConfig& config)
      {
        return _vector.set_checkpoint_data(data, config);
      }
    }; // class Vector<...>
  } // namespace Global
} // namespace FEAT