DOFVector.hpp 4.47 KB
Newer Older
1
2
#pragma once

3
4
5
6
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

7
8
9
10
11
12
#include <string>
#include <memory>

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

#include <dune/amdis/Log.hpp>
13
14
#include <dune/amdis/common/ClonablePtr.hpp>
#include <dune/amdis/common/ScalarTypes.hpp>
15
#include <dune/amdis/linear_algebra/mtl/MTLDenseVector.hpp>
16
17
18

namespace AMDiS
{
19
  /// The basic container that stores a base vector and a corresponding feSpace
20
21
22
23
24
25
  template <class FeSpaceType, class ValueType = double>
  class DOFVector
  {
    using Self = DOFVector;
      
  public:
26
    /// The type of the \ref feSpace
27
    using FeSpace    = FeSpaceType;
28
29
    
    /// The type of the base vector
30
    using BaseVector = MTLDenseVector<ValueType>;
31
    
32
    /// The index/size - type
33
34
    using size_type  = typename FeSpace::size_type;
    
35
    /// The type of the elements of the DOFVector
36
    using value_type = ValueType;
37
38
    
    /// The underlying field-type (typically the same as \ref value_type)
39
40
41
42
43
44
45
46
47
48
49
    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();
    }
    
50
    /// Constructor. Takes reference to existing BaseVector
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
    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()
    {
91
92
      if (num_rows(*vector) != getSize())
        vector->change_dim(getSize());
93
94
95
96
97
98
    }
    
    
    /// Access the entry \p i of the \ref vector with read-access.
    value_type const& operator[](size_type i) const
    {
99
100
      AMDIS_TEST_EXIT_DBG( i < num_rows(*vector) , 
        "Index " << i << " out of range [0," << num_rows(*vector) << ")" );
101
102
103
104
105
106
      return (*vector)[i];
    }
    
    /// Access the entry \p i of the \ref vector with write-access.
    value_type& operator[](size_type i)
    {
107
108
      AMDIS_TEST_EXIT_DBG( i < num_rows(*vector) , 
        "Index " << i << " out of range [0," << num_rows(*vector) << ")" );
109
110
111
      return (*vector)[i];
    }
    
112
    /// \brief interpolate a function \p f to the basis \ref feSpace and store the
113
114
115
116
    /// coefficients in \ref vector.
    template <class F>
    void interpol(F const& f)
    {
117
118
      // 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.
119
      Dune::Functions::interpolate(feSpace, wrapper(*vector), f);
120
121
    }
    
122
123
    /// Scale each DOFVector by the factor \p s.
    template <class Scalar>
124
    std::enable_if_t< Concepts::Arithmetic<Scalar>, Self&>
125
126
127
128
129
130
131
132
    operator*=(Scalar s)
    {
      (*vector) *= s;
      return *this;
    }
    
    /// Sets each DOFVector to the scalar \p s.
    template <class Scalar>
133
    std::enable_if_t< Concepts::Arithmetic<Scalar>, Self&>
134
135
136
137
138
139
    operator=(Scalar s)
    {
      (*vector) = s;
      return *this;
    }
    
140
141
142
143
144
145
146
    /// Calls the copy assignment operator of the BaseVector \ref vector
    void copy(Self const& that)
    {
      *vector = that.getVector();
    }
      
  private:
147
    /// The finite element space / basis associated with the data vector
148
    FeSpace const& feSpace;
149
150
    
    /// The name of the DOFVector (used in file-writing)
151
152
    std::string	name;
    
153
    /// The data-vector (can hold a new BaseVector or a pointer to external data
154
155
156
157
158
    ClonablePtr<BaseVector> vector;
      
    // friend class declarations
    template <class, class> friend class SystemVector;
  };
159
160
161
162
163
  
  
  /// Constructor a dofvector from given feSpace and name
  template <class FeSpaceType, class ValueType = double>
  DOFVector<FeSpaceType, ValueType>
164
  makeDOFVector(FeSpaceType const& feSpace, std::string name)
165
166
167
  {
    return {feSpace, name};
  }
168
169

} // end namespace AMDiS