DOFVector.hpp

#pragma once

#include <string>
#include <memory>

#include <dune/istl/bvector.hh>

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

#include <amdis/Output.hpp>
#include <amdis/common/ClonablePtr.hpp>

namespace AMDiS
{
    template <class FeSpaceType, class ValueType = Dune::FieldVector<double,1>>
    class DOFVector
    {
        using Self = DOFVector;

    public:
	using FeSpace    = FeSpaceType;
	using BaseVector = Dune::BlockVector<ValueType>;

	using size_type  = typename FeSpace::size_type;
	using field_type = typename ValueType::field_type;

	using value_type = ValueType;

	/// Constructor. Constructs new BaseVector.
	DOFVector(FeSpace const& feSpace, std::string name)
	  : feSpace(feSpace)
	  , name(name)
	  , vector(ClonablePtr<BaseVector>::make())
	{
	    compress();
	}

	/// Constructor. Takes pointer of data-vector.
	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& vector() const
	{
	    return *vector;
	}

	/// Return the data-vector \ref vector
	BaseVector& vector()
	{
	    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->resize(getSize() / value_type::dimension);
	}


	/// Access the entry \p i of the \ref vector with read-access.
	value_type const& operator[](size_type i) const
	{
	    test_exit_dbg(i < vector->size() ,
                          "Index ", i, " out of range [0,", vector->size(), ")" );
	    return (*vector)[i];
	}

	/// Access the entry \p i of the \ref vector with write-access.
	value_type& operator[](size_type i)
	{
	    test_exit_dbg(i < vector->size() ,
                          "Index ", i, " out of range [0,", vector->size(), ")" );
	    return (*vector)[i];
	}

	/// 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)
	{
	    Dune::Functions::interpolate(feSpace, *vector, f);
	}

	/// Calls the copy assignment operator of the BaseVector \ref vector
	void copy(Self const& that)
	{
		*vector = that.vector();
	}

    private:
	FeSpace const&	feSpace;
	std::string	name;

	ClonablePtr<BaseVector> vector;

    // friend class declarations
    template <class, class>
    friend class SystemVector;
    };

} // end namespace AMDiS