BasisFunction.h 12.6 KB
Newer Older
1
2
3
4
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
5
// ==  http://www.amdis-fem.org                                              ==
6
7
// ==                                                                        ==
// ============================================================================
8
9
10
11
12
13
14
15
16
17
18
19
//
// Software License for AMDiS
//
// Copyright (c) 2010 Dresden University of Technology 
// All rights reserved.
// Authors: Simon Vey, Thomas Witkowski et al.
//
// This file is part of AMDiS
//
// See also license.opensource.txt in the distribution.


20
21
22
23
24
25
26

/** \file BasisFunction.h */

#ifndef AMDIS_BASISFUNCTION_H
#define AMDIS_BASISFUNCTION_H

#include <string>
27
#include "AMDiS_fwd.h"
28
29
#include "Global.h"
#include "Boundary.h"
Thomas Witkowski's avatar
Thomas Witkowski committed
30
#include "MatrixVector.h"
31
#include "FixVec.h"
32
33
34

namespace AMDiS {

35
36
  using namespace std;

37
  /// Function interface for evaluating basis functions.
38
39
40
  class BasFctType
  {
  public:
41
    BasFctType() {}
42

43
    virtual ~BasFctType() {}
44
45
46
47

    virtual double operator()(const DimVec<double>&) const = 0;
  };

48

49
  /// Function interface for evaluating gradients of basis functions. 
50
51
52
  class GrdBasFctType
  {
  public:
53
    GrdBasFctType() {}
54

55
    virtual ~GrdBasFctType() {}
56

57
58
    virtual void operator()(const DimVec<double>&, 
			    mtl::dense_vector<double>&) const = 0;
59
60
  };
  
61

62
  /// Function interface for evaluating second derivative of basis functions.
63
64
65
  class D2BasFctType
  {
  public:
66
    D2BasFctType() {}
67

68
    virtual ~D2BasFctType() {}
69

70
    virtual void operator()(const DimVec<double>&, DimMat<double>&) const = 0;
71
  };
72

73
			    
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
  typedef BasFctType *BFptr;
  typedef GrdBasFctType *GBFptr;
  typedef D2BasFctType *DBFptr;

  /** \ingroup FEMSpace
   * \brief
   * Base class for finite element basis functions. In order to build up a
   * finite element space, we have to specify a set of local basis functions.
   * Together with the correspondig DOF administration and the underlying mesh,
   * the finite element space is given. 
   * This class holds the local basis functions and their derivatives of the
   * reference element. They are evaluated at barycentric coordinates, so they
   * can be used on every element of the mesh.  
   */
  class BasisFunction
  {  
  protected:
91
    /// Creates a BasisFunction object of given dim and degree 
92
    BasisFunction(string name, int dim, int degree);
93

94
    /// destructor
95
96
97
    virtual ~BasisFunction();

  public:
98
    /// compares two BasisFunction objects.
Thomas Witkowski's avatar
Thomas Witkowski committed
99
100
    virtual bool operator==(const BasisFunction& a) const 
    {
101
      return a.getName() == name;
102
    }
103

104
    /// Returns !(*this == b)
Thomas Witkowski's avatar
Thomas Witkowski committed
105
106
    inline bool operator!=(const BasisFunction& b) const 
    {
107
      return !(operator == (b));
108
    }
109

110
    /// Used by \ref getDOFIndices and \ref getVec
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
    virtual int* orderOfPositionIndices(const Element* el, GeoIndex position, 
					int positionIndex) const = 0;

    /** \brief
     * Pointer to a function which connects the set of local basis functions
     * with its global DOFs.
     * getDOFIndices(el, admin, dof) returns a pointer to a const vector of 
     * length \ref nBasFcts where the i-th entry is the index of the DOF 
     * associated to the i-th basis function; arguments are the actual element 
     * el and the DOF admin admin of the corresponding finite element space 
     * (these indices depend on all defined DOF admins and thus on the 
     * corresponding admin); if the last argument dof is NULL, getDOFndices 
     * has to provide memory for storing this vector, which is overwritten on the
     * next call of getDOFIndices; if dof is not NULL, dof is a pointer to a 
     * vector which has to be filled;   
     */
    virtual const DegreeOfFreedom* getDOFIndices(const Element*,
						 const DOFAdmin&, 
						 DegreeOfFreedom*) const = 0;

    /** \brief
Thomas Witkowski's avatar
Thomas Witkowski committed
132
133
134
135
136
137
138
139
140
     * The second argument 'bound' has to be a pointer to a vector which has 
     * to be filled. Its length is \ref nBasFcts (the number of basis functions
     * in the used finite element space). After calling this function, the i-th 
     * entry of the array is the boundary type of the i-th basis function of this
     * element.
     * 
     * This function needs boundary information within the ElInfo object; thus, 
     * all routines using this function on the elements need the FILL_BOUND 
     * flag during mesh traversal;
141
     */
142
    virtual void getBound(const ElInfo*, BoundaryType *) const {}
143

Thomas Witkowski's avatar
Thomas Witkowski committed
144
    /// Returns \ref degree of BasisFunction
Thomas Witkowski's avatar
Thomas Witkowski committed
145
146
    inline const int getDegree() const 
    { 
147
      return degree; 
148
    }
149

Thomas Witkowski's avatar
Thomas Witkowski committed
150
    /// Returns \ref dim of BasisFunction
Thomas Witkowski's avatar
Thomas Witkowski committed
151
152
    inline const int getDim() const 
    { 
153
      return dim; 
154
    }
155

Thomas Witkowski's avatar
Thomas Witkowski committed
156
    /// Returns \ref nBasFcts which is the number of local basis functions
Thomas Witkowski's avatar
Thomas Witkowski committed
157
158
    inline const int getNumber() const 
    { 
159
      return nBasFcts; 
160
    }
161

Thomas Witkowski's avatar
Thomas Witkowski committed
162
    /// Returns \ref name of BasisFunction
163
    inline string getName() const 
Thomas Witkowski's avatar
Thomas Witkowski committed
164
    { 
165
      return name; 
166
    }
167

Thomas Witkowski's avatar
Thomas Witkowski committed
168
    /// Returns \ref nDOF[i]
169
    int getNumberOfDofs(int i) const;
170

Thomas Witkowski's avatar
Thomas Witkowski committed
171
    /// Returns \ref nDOF
172
    inline DimVec<int>* getNumberOfDofs() const 
Thomas Witkowski's avatar
Thomas Witkowski committed
173
    { 
174
      return nDOF; 
175
    }
176

Thomas Witkowski's avatar
Thomas Witkowski committed
177
    /// Initialisation of the \ref nDOF vector. Must be implemented by sub classes
178
179
    virtual void setNDOF() = 0;

Thomas Witkowski's avatar
Thomas Witkowski committed
180
    /// Returns the barycentric coordinates of the i-th basis function.
181
182
183
    virtual DimVec<double> *getCoords(int i) const = 0;

    /** \brief
184
     * Fills a vector with interpolation coefficients of the
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
     * function f; if indices is a pointer to NULL, the coefficient for all 
     * basis functions are calculated and the i-th entry in the vector is the 
     * coefficient of the i-th basis function; if indices is non NULL, only the 
     * coefficients for a subset of the local basis functions has to be 
     * calculated; n is the number of those basis functions, indices[0], . . . 
     * , indices[n-1] are the local indices of the basis functions where the
     * coefficients have to be calculated, and the i-th entry in the return 
     * vector is then the coefficient of the indices[i]-th basis function; coeff 
     * may be a pointer to a vector which has to be filled 
     * (compare the dof argument of \ref getDOFIndices());
     * such a function usually needs vertex coordinate information; thus, all 
     * routines using this function on the elements need the FILL COORDS flag 
     * during mesh traversal.
     * Must be implemented by sub classes.
     */
200
201
202
203
204
    virtual void interpol(const ElInfo *el_info, 
			  int n, 
			  const int *indices, 
			  AbstractFunction<double, WorldVector<double> > *f,
			  mtl::dense_vector<double> &coeff) const = 0;
205

206
    /// WorldVector<double> valued interpol function.
207
208
209
210
211
    virtual void interpol(const ElInfo *el_info, 
			  int no, 
			  const int *b_no,
			  AbstractFunction<WorldVector<double>, WorldVector<double> > *f, 
			  mtl::dense_vector<WorldVector<double> >& coeff) const = 0;
212

213
    /// Returns the i-th local basis function
Thomas Witkowski's avatar
Thomas Witkowski committed
214
215
    inline BasFctType *getPhi(int i) const 
    { 
216
      return (*phi)[i]; 
217
    }
218

219
    /// Returns the gradient of the i-th local basis function
Thomas Witkowski's avatar
Thomas Witkowski committed
220
221
    inline GrdBasFctType *getGrdPhi(int i) const 
    { 
222
      return (*grdPhi)[i]; 
223
    }
224

225
    /// Returns the second derivative of the i-th local basis function
Thomas Witkowski's avatar
Thomas Witkowski committed
226
227
    inline D2BasFctType *getD2Phi(int i) const 
    { 
228
      return (*d2Phi)[i]; 
229
    }
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252

    /** \brief
     * Approximates the L2 scalar products of a given function with all basis 
     * functions by numerical quadrature and adds the corresponding values to a 
     * DOF vector;
     * f is a pointer for the evaluation of the given function in world 
     * coordinates x and returns the value of that function at x; if f is a NULL
     *  pointer, nothing is done;
     * fh is the DOF vector where at the i-th entry the approximation of the L2 
     * scalar product of the given function with the i-th global basis function 
     * of fh->feSpace is stored;
     * quad is the quadrature for the approximation of the integral on each leaf 
     * element of fh->feSpace->mesh; if quad is a NULL pointer, a default 
     * quadrature which is exact of degree 2*fh->feSpace->basFcts->degree-2 is 
     * used.
     * The integrals are approximated by looping over all leaf elements, 
     * computing the approximations to the element contributions and adding 
     * these values to the vector fh by add element vec().
     * The vector fh is not initialized with 0.0; only the new contributions are 
     * added
     */
    virtual void l2ScpFctBas(Quadrature*,
			     AbstractFunction<double, WorldVector<double> >* /*f*/,
253
254
			     DOFVector<double>* /*fh*/)
    {}
255

256
    /// WorldVector<double> valued l2ScpFctBas function
257
258
    virtual void l2ScpFctBas(Quadrature* ,
			     AbstractFunction<WorldVector<double>, WorldVector<double> >* /*f*/,
259
260
			     DOFVector<WorldVector<double> >* /*fh*/) 
    {}
261
262


263
264
    /// Interpolates a DOFIndexed<double> after refinement
    virtual void refineInter(DOFIndexed<double> *, RCNeighbourList*, int)
265
    {}
266

267
268
    /// Interpolates a DOFIndexed<double> after coarsening
    virtual void coarseInter(DOFIndexed<double> *, RCNeighbourList*, int)
269
    {}
270

271
272
    /// Restricts a DOFIndexed<double> after coarsening
    virtual void coarseRestr(DOFIndexed<double> *, RCNeighbourList*, int)
273
    {}
274

275
276
    /// Interpolates a DOFVector<WorldVector<double> > after refinement
    virtual void refineInter(DOFVector<WorldVector<double> >*, RCNeighbourList*, int)
277
    {}
278

279
280
    /// Interpolates a DOFVector<WorldVector<double> > after coarsening
    virtual void coarseInter(DOFVector<WorldVector<double> >*, RCNeighbourList*, int)
281
    {}
282

283
284
    /// Restricts a DOFVector<WorldVector<double> > after coarsening
    virtual void coarseRestr(DOFVector<WorldVector<double> >*, RCNeighbourList*, int)
285
    {}
286

287
    /// Returns local dof indices of the element for the given fe space.
Thomas Witkowski's avatar
Thomas Witkowski committed
288
289
290
    virtual const DegreeOfFreedom *getLocalIndices(const Element *el,
						   const DOFAdmin *admin,
						   DegreeOfFreedom *dofPtr) const
291
292
    {
      return NULL;
293
    }
294

295
296
    inline void getLocalIndices(const Element *el,
				const DOFAdmin *admin,
297
				vector<DegreeOfFreedom> &indices) const
298
299
300
301
302
303
304
305
    {
      FUNCNAME("BasisFunction::getLocalIndices()");
      
      TEST_EXIT_DBG(static_cast<int>(indices.size()) >= nBasFcts)
	("Index vector is too small!\n");

      getLocalIndices(el, admin, &(indices[0]));
    }
Thomas Witkowski's avatar
Thomas Witkowski committed
306

Thomas Witkowski's avatar
Thomas Witkowski committed
307
308
    virtual void getLocalDofPtrVec(const Element *el, 
				   const DOFAdmin *admin,
309
				   vector<const DegreeOfFreedom*>& vec) const
310
    {}
Thomas Witkowski's avatar
Thomas Witkowski committed
311

312
313
314
315
316

    /** \brief
     * Evaluates elements value at barycentric coordinates lambda with local 
     * coefficient vector uh.
     */
317
318
    template<typename T>
    T evalUh(const DimVec<double>& lambda, const mtl::dense_vector<T>& uh) const;
319
320


321
322
323
324
325
326
327
    /** \brief
     * Evaluates the gradient at barycentric coordinates lambda. Lambda is the
     * Jacobian of the barycentric coordinates. uh is the local coefficient
     * vector. If val is not NULL the result will be stored 
     * there, otherwise a pointer to a static local variable is returned which 
     * will be overwritten after the next call.
     */
328
329
330
331
332
333
    template<typename T>
    typename GradientType<T>::type& evalGrdUh(const DimVec<double>& lambda,
					      const DimVec<WorldVector<double> >& Lambda,
					      const mtl::dense_vector<T>& uh,
					      typename GradientType<T>::type& val) const;

334
335
336
337
338
339
340
341
342
343

    /** \brief
     * Evaluates the second derivative at barycentric coordinates lambda. 
     * Lambda is the Jacobian of the barycentric coordinates. uh is the local 
     * coefficient vector. If val is not NULL the result will be stored 
     * there, otherwise a pointer to a static local variable is returned which 
     * will be overwritten after the next call.
     */
    const WorldMatrix<double>& evalD2Uh(const DimVec<double>& lambda,
					const DimVec<WorldVector<double> >& Lambda,
Thomas Witkowski's avatar
Thomas Witkowski committed
344
345
					const ElementVector& uh,
					WorldMatrix<double>* val) const;
346
347

  protected:
348
    /// Textual description
349
    string name;     
350

351
    /// Number of basisfunctions on one Element                 
352
353
    int nBasFcts;

354
    /// Maximal degree of the basis functions                 
355
356
    int degree;

357
    /// Dimension of the basis functions                  
358
359
    int dim;

360
    /// Dimension of the world.
Thomas Witkowski's avatar
Thomas Witkowski committed
361
362
    int dow;

363
    /// Number of DOFs at the different positions                  
364
365
    DimVec<int> *nDOF;

366
    /// Vector of the local functions
367
    vector<BasFctType*> *phi;
368

369
    /// Vector of gradients
370
    vector<GrdBasFctType*> *grdPhi;
371

372
    /// Vector of second derivatives
373
    vector<D2BasFctType*> *d2Phi;
374
375
376
  };

}
377
#include "BasisFunction.hh"
378
379

#endif  // AMDIS_BASISFUNCTION_H