DOFVector.hpp 3.63 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#pragma once

#include <string>
#include <memory>


#include <boost/numeric/mtl/vector/dense_vector.hpp>

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

#include <dune/amdis/ClonablePtr.hpp>
#include <dune/amdis/Log.hpp>

namespace AMDiS
{
16
  /// The basic container that stores a base vector and a corresponding feSpace
17
18
19
20
21
22
  template <class FeSpaceType, class ValueType = double>
  class DOFVector
  {
    using Self = DOFVector;
      
  public:
23
    /// The type of the \ref feSpace
24
    using FeSpace    = FeSpaceType;
25
26
    
    /// The type of the base vector
27
28
    using BaseVector = mtl::dense_vector<ValueType>;
    
29
    /// The index/size - type
30
31
    using size_type  = typename FeSpace::size_type;
    
32
    /// The type of the elements of the DOFVector
33
    using value_type = ValueType;
34
35
    
    /// The underlying field-type (typically the same as \ref value_type)
36
37
38
39
40
41
42
43
44
45
46
    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();
    }
    
47
    /// Constructor. Takes reference to existing BaseVector
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
    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 < 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)
    {
      AMDIS_TEST_EXIT_DBG( i < vector->size() , 
        "Index " << i << " out of range [0," << vector->size() << ")" );
      return (*vector)[i];
    }
    
108
    /// \brief interpolate a function \p f to the basis \ref feSpace and store the
109
110
111
112
    /// coefficients in \ref vector.
    template <class F>
    void interpol(F const& f)
    {
113
114
      // 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.
115
116
117
118
119
120
121
122
123
124
      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:
125
    /// The finite element space / basis associated with the data vector
126
    FeSpace const&	feSpace;
127
128
    
    /// The name of the DOFVector (used in file-writing)
129
130
    std::string	name;
    
131
    /// The data-vector (can hold a new BAseVector or a pointer to external data
132
133
134
135
136
137
138
    ClonablePtr<BaseVector> vector;
      
    // friend class declarations
    template <class, class> friend class SystemVector;
  };

} // end namespace AMDiS