dune-fem  2.4.1-rc
functionspace.hh
Go to the documentation of this file.
1 #ifndef DUNE_FEM_FUNCTIONSPACE_HH
2 #define DUNE_FEM_FUNCTIONSPACE_HH
3 
5 #include <dune/common/fmatrix.hh>
6 
7 namespace Dune
8 {
9 
10  namespace Fem
11  {
12 
13  // Forward declaration of
14  // base class for vector valued function spaces.
15  template< class DomainField, class RangeField, int dimD, int dimR>
17 
19  template< class DomainField, class RangeField, int dimD, int dimR>
21  {
23  typedef DomainField DomainFieldType;
25  typedef RangeField RangeFieldType;
26 
28  enum { dimDomain = dimD };
30  enum { dimRange = dimR };
31 
33  typedef FieldVector< DomainFieldType, dimDomain > DomainType;
34 
36  typedef FieldVector< RangeFieldType, dimRange> RangeType;
37 
39  typedef FieldMatrix< RangeFieldType, dimRange, dimDomain > LinearMappingType;
40 
44  };
45 
52  template< class DomainField, class RangeField, int dimD, int dimR>
53  class FunctionSpace
54  : public FunctionSpaceInterface
55  < VectorSpaceTraits< DomainField, RangeField, dimD, dimR> >
56  {
58 
59  public:
60  typedef ThisType FunctionSpaceType;
61  };
62 
63  /* Forward declaration of
64  base class for matrix valued function spaces.
65  */
66  template <typename DomainFieldImp,typename RangeFieldImp,int n,int m1,int m2>
68 
72  template <typename K,int n,int m>
73  class RangeMatrix : public FieldMatrix<K,n,m> {
74  public:
75  typedef FieldMatrix<K,n,m> BaseType;
76  typedef typename BaseType::row_type RowType;
77  enum {
79  rows = BaseType::rows,
81  cols = BaseType::cols,
83  dimension = BaseType::rows*BaseType::cols
84  };
85  //===== constructors
88  RangeMatrix () : BaseType() {}
89 
92  RangeMatrix (const K& k) : BaseType(k) {}
93 
99  K& operator()(int r,int c) {
100  return static_cast<BaseType&>(*this)[r][c];
101  }
107  const K operator()(int r,int c) const {
108  return static_cast<const BaseType&>(*this)[r][c];
109  }
114  const RowType& row(int r) const{
115  return static_cast<BaseType&>(*this)[r];
116  }
121  RowType& row(int r){
122  return static_cast<BaseType&>(*this)[r];
123  }
124 
129  K& operator[](int i) {
130  int r = i/cols;
131  int c = i%cols;
132  return (*this)(r,c);
133  }
138  const K operator[](int i) const {
139  int r = i/cols;
140  int c = i%cols;
141  return (*this)(r,c);
142  }
143 
148  K operator* (const BaseType& y)
149  {
150  K ret(0);
151  for (int i=0; i<n; i++)
152  ret += static_cast<BaseType&>(*this)[i] * y[i];
153  return ret;
154  }
155 
161  RangeMatrix& axpy (const K& a, const BaseType& y)
162  {
163  for (int i=0; i<n; i++)
164  static_cast<BaseType&>(*this)[i].axpy(a,y[i]);
165  return *this;
166  }
167  };
171  template <typename DomainFieldImp,typename RangeFieldImp,int n,int m1,int m2>
173  public FieldMatrix<RangeFieldImp,m1*m2,n> {
174  // Implement L : VD -> VR where VR is the space of FieldMatrix<RFI,m1,m2>
175  // VD is space of FieldVector<DFT,n>
176  public:
178  typedef DomainFieldImp DomainFieldType;
180  typedef RangeFieldImp RangeFieldType;
184  typedef FieldMatrix<RangeFieldImp,m1*m2,n> BaseType;
185  //===== constructors
188  MatrixMapping () : BaseType() {}
191  MatrixMapping (const RangeFieldImp& k) : BaseType(k) {}
192 
197  FieldVector<DomainFieldImp,n>& operator[](int i) {
198  return static_cast<BaseType&>(*this)[i];
199  }
204  const FieldVector<DomainFieldImp,n>& operator[](int i) const {
205  return static_cast<const BaseType&>(*this)[i];
206  }
207  };
208 
210  template <typename DomainFieldImp,typename RangeFieldImp,int n,int m1,int m2>
213  typedef DomainFieldImp DomainFieldType;
215  typedef RangeFieldImp RangeFieldType;
217  typedef FieldVector<DomainFieldImp, n> DomainType;
225  enum { dimRange = m1 * m2};
227  enum { dimDomain = n };
228  };
229 
233  template <typename DomainFieldImp,typename RangeFieldImp,int n,int m1,int m2>
234  class MatrixFunctionSpace : public
235  FunctionSpaceInterface<MatrixSpaceTraits<DomainFieldImp,RangeFieldImp,n,m1,m2> > {};
236 
237  // function space converter objects
238  // --------------------------------
239 
241  template < class FunctionSpaceImp, int newDimDomain >
243 
245  template < class FunctionSpaceImp, int newDimRange >
247 
249  template< class DomainFieldImp, class RangeFieldImp, int dimDomain, int dimRange, int newDimDomain >
250  struct ToNewDimDomainFunctionSpace< FunctionSpace< DomainFieldImp, RangeFieldImp, dimDomain, dimRange >, newDimDomain >
251  {
253  };
254 
256  template< class DomainFieldImp, class RangeFieldImp, int n, int m1, int m2, int newDimDomain >
257  struct ToNewDimDomainFunctionSpace< MatrixFunctionSpace< DomainFieldImp, RangeFieldImp, n, m1, m2 >, newDimDomain >
258  {
260  };
261 
263  template< class DomainFieldImp, class RangeFieldImp, int dimDomain, int dimRange, int newDimRange >
264  struct ToNewDimRangeFunctionSpace< FunctionSpace< DomainFieldImp, RangeFieldImp, dimDomain, dimRange >, newDimRange >
265  {
267  };
268 
269  } // namespace Fem
270 
271 } // namespace Dune
272 
273 #endif // #ifndef DUNE_FEM_FUNCTIONSPACE_HH
FieldMatrix< RangeFieldImp, m1 *m2, n > BaseType
type of base class
Definition: functionspace.hh:184
RangeType class for matrix valued functions - derived from FieldMatrix but has representation as vect...
Definition: functionspace.hh:73
ThisType FunctionSpaceType
Definition: functionspace.hh:60
BaseType::row_type RowType
Definition: functionspace.hh:76
DomainFieldImp DomainFieldType
Intrinsic type used for values in the domain field (usually a double)
Definition: functionspace.hh:178
DomainFieldImp DomainFieldType
Intrinsic type used for values in the domain field (usually a double)
Definition: functionspace.hh:213
K & operator()(int r, int c)
access element in row r and column c
Definition: functionspace.hh:99
A vector valued function space.
Definition: functionspace.hh:16
FieldMatrix< RangeFieldType, dimRange, dimDomain > LinearMappingType
linear mapping type
Definition: functionspace.hh:39
FieldVector< RangeFieldType, dimRange > RangeType
Type of range vector (using type of range field) has a Dune::FieldVector type interface.
Definition: functionspace.hh:36
FieldVector< DomainFieldType, dimDomain > DomainType
Type of domain vector (using type of domain field) has a Dune::FieldVector type interface.
Definition: functionspace.hh:33
RangeMatrix(const K &k)
Constructor initializing the whole matrix with a scalar.
Definition: functionspace.hh:92
MatrixMapping()
Default constructor.
Definition: functionspace.hh:188
Traits class for matrix valued spaces.
Definition: functionspace.hh:211
Definition: functionspace.hh:30
FieldMatrix< K, n, m > BaseType
Definition: functionspace.hh:75
RangeMatrix< RangeFieldImp, m1, m2 > RangeType
Type of range vector (using type of range field) has a Dune::FieldVector type interface.
Definition: functionspace.hh:182
RangeFieldImp RangeFieldType
Intrinsic type used for values in the range field (usually a double)
Definition: functionspace.hh:215
MatrixFunctionSpace< DomainFieldImp, RangeFieldImp, n, 1, 1 > ScalarFunctionSpaceType
scalar function space type
Definition: functionspace.hh:223
FieldVector< DomainFieldImp, n > DomainType
Type of domain vector (using type of domain field) has a Dune::FieldVector type interface.
Definition: functionspace.hh:217
interface for an arbitrary function spaceBase class for specific function spaces. ...
Definition: functionspaceinterface.hh:38
DomainField DomainFieldType
Intrinsic type used for values in the domain field (usually a double)
Definition: functionspace.hh:23
Definition: functionspace.hh:28
const K operator[](int i) const
access i element where row = i/col and column = icol
Definition: functionspace.hh:138
RangeMatrix & axpy(const K &a, const BaseType &y)
vector space axpy operation
Definition: functionspace.hh:161
Definition: coordinate.hh:4
FunctionSpace< DomainFieldType, RangeFieldType, dimDomain, 1 > ScalarFunctionSpaceType
scalar function space type
Definition: functionspace.hh:43
const RowType & row(int r) const
access to row r
Definition: functionspace.hh:114
RangeFieldImp RangeFieldType
Intrinsic type used for values in the range field (usually a double)
Definition: functionspace.hh:180
A matrix valued function space.
Definition: functionspace.hh:67
MatrixMapping(const RangeFieldImp &k)
Constructor initializing the whole matrix with a scalar.
Definition: functionspace.hh:191
Double operator*(const Double &a, const Double &b)
Definition: double.hh:495
MatrixMapping< DomainFieldImp, RangeFieldImp, n, m1, m2 > LinearMappingType
linear mapping type
Definition: functionspace.hh:221
RangeMatrix< RangeFieldImp, m1, m2 > RangeType
Type of range vector (using type of range field) has a Dune::FieldVector type interface.
Definition: functionspace.hh:219
FunctionSpace< DomainFieldImp, RangeFieldImp, dimDomain, newDimRange > Type
Definition: functionspace.hh:266
MatrixFunctionSpace< DomainFieldImp, RangeFieldImp, newDimDomain, m1, m2 > Type
Definition: functionspace.hh:259
const K operator()(int r, int c) const
access element in row r and column c
Definition: functionspace.hh:107
FieldVector< DomainFieldImp, n > & operator[](int i)
returning reference to row
Definition: functionspace.hh:197
const FieldVector< DomainFieldImp, n > & operator[](int i) const
returning reference to row
Definition: functionspace.hh:204
RangeMatrix()
Default constructor.
Definition: functionspace.hh:88
RowType & row(int r)
access to row r
Definition: functionspace.hh:121
FunctionSpace< DomainFieldImp, RangeFieldImp, newDimDomain, dimRange > Type
Definition: functionspace.hh:252
RangeField RangeFieldType
Intrinsic type used for values in the range field (usually a double)
Definition: functionspace.hh:25
convert functions space to space with new dim domain
Definition: functionspace.hh:242
Traits class for vector function spaces.
Definition: functionspace.hh:20
K & operator[](int i)
access i element where row = i/col and column = icol
Definition: functionspace.hh:129
convert functions space to space with new dim range
Definition: functionspace.hh:246
JacobianRangeType class for matrix valued functions - derived from FieldMatrix.
Definition: functionspace.hh:172