DOFVector.hpp

#pragma once

#include <string>
#include <memory>

#include <dune/functions/functionspacebases/interpolate.hh>

#include <dune/amdis/ClonablePtr.hpp>
#include <dune/amdis/Log.hpp>
#include <dune/amdis/linear_algebra/mtl/MTLDenseVector.hpp>

namespace AMDiS
{
  /// The basic container that stores a base vector and a corresponding feSpace
  template <class FeSpaceType, class ValueType = double>
  class DOFVector
  {
    using Self = DOFVector;
      
  public:
    /// The type of the \ref feSpace
    using FeSpace    = FeSpaceType;
    
    /// The type of the base vector
    using BaseVector = MTLDenseVector<ValueType>;
    
    /// The index/size - type
    using size_type  = typename FeSpace::size_type;
    
    /// The type of the elements of the DOFVector
    using value_type = ValueType;
    
    /// The underlying field-type (typically the same as \ref value_type)
    using field_type = typename BaseVector::value_type;
    
    /// Constructor. Constructs new BaseVector.
    DOFVector(FeSpace const& feSpace, std::string name)
      : feSpace(feSpace)
      , name(name)
      , vector(ClonablePtr<BaseVector>::make())
    {
      compress();
    }
    
    /// Constructor. Takes reference to existing BaseVector
    DOFVector(FeSpace const& feSpace, std::string name, 
              BaseVector& vector_ref)
      : feSpace(feSpace)
      , name(name)
      , vector(vector_ref)
    {}
    
    /// Return the basis \ref feSpace of the vector
    FeSpace const& getFeSpace() const
    {
        return feSpace;
    }
    
    /// Return the data-vector \ref vector
    BaseVector const& getVector() const
    {
      return *vector;
    }
    
    /// Return the data-vector \ref vector
    BaseVector& getVector()
    {
      return *vector;
    }
    
    /// Return the size of the \ref feSpace
    size_type getSize() const
    {
      return feSpace.size();
    }
    
    /// Return the \ref name of this vector
    std::string getName() const
    {
      return name;
    }
    
    /// Resize the \ref vector to the size of the \ref feSpace.
    void compress()
    {
      vector->change_dim(getSize());
    }
    
    
    /// Access the entry \p i of the \ref vector with read-access.
    value_type const& operator[](size_type i) const
    {
      AMDIS_TEST_EXIT_DBG( i < num_rows(*vector) , 
        "Index " << i << " out of range [0," << num_rows(*vector) << ")" );
      return (*vector)[i];
    }
    
    /// Access the entry \p i of the \ref vector with write-access.
    value_type& operator[](size_type i)
    {
      AMDIS_TEST_EXIT_DBG( i < num_rows(*vector) , 
        "Index " << i << " out of range [0," << num_rows(*vector) << ")" );
      return (*vector)[i];
    }
    
    /// \brief interpolate a function \p f to the basis \ref feSpace and store the
    /// coefficients in \ref vector.
    template <class F>
    void interpol(F const& f)
    {
      // NOTE: This needs a change in mtl dense_vector implementation, i.e. we
      // have to add an alias for the function change_dim with the name resize.
      Dune::Functions::interpolate(feSpace, *vector, f);
    }
    
    /// Calls the copy assignment operator of the BaseVector \ref vector
    void copy(Self const& that)
    {
      *vector = that.getVector();
    }
      
  private:
    /// The finite element space / basis associated with the data vector
    FeSpace const& feSpace;
    
    /// The name of the DOFVector (used in file-writing)
    std::string	name;
    
    /// The data-vector (can hold a new BaseVector or a pointer to external data
    ClonablePtr<BaseVector> vector;
      
    // friend class declarations
    template <class, class> friend class SystemVector;
  };
  
  
  /// Constructor a dofvector from given feSpace and name
  template <class FeSpaceType, class ValueType = double>
  DOFVector<FeSpaceType, ValueType>
  make_dofvector(FeSpaceType const& feSpace, std::string name)
  {
    return {feSpace, name};
  }

} // end namespace AMDiS