BasisFunction.h 13.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  crystal growth group                                                  ==
// ==                                                                        ==
// ==  Stiftung caesar                                                       ==
// ==  Ludwig-Erhard-Allee 2                                                 ==
// ==  53175 Bonn                                                            ==
// ==  germany                                                               ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  http://www.caesar.de/cg/AMDiS                                         ==
// ==                                                                        ==
// ============================================================================

/** \file BasisFunction.h */

#ifndef AMDIS_BASISFUNCTION_H
#define AMDIS_BASISFUNCTION_H

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

namespace AMDiS {

33
  /// Function interface for evaluating basis functions.
34
35
36
  class BasFctType
  {
  public:
37
    BasFctType() {}
38

39
    virtual ~BasFctType() {}
40
41
42
43

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

44
  /// Function interface for evaluating gradients of basis functions. 
45
46
47
  class GrdBasFctType
  {
  public:
48
    GrdBasFctType() {}
49

50
    virtual ~GrdBasFctType() {}
51
52
53
54
55

    virtual void operator()(const DimVec<double>&,
			    DimVec<double>&) const = 0;
  };
  
56
  /// Function interface for evaluating second derivative of basis functions.
57
58
59
  class D2BasFctType
  {
  public:
60
    D2BasFctType() {}
61

62
    virtual ~D2BasFctType() {}
63
64
65
66
67

    virtual void operator()(const DimVec<double>&,
			    DimMat<double>&) const = 0;
  };
			    
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
  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:
85
    /// Creates a BasisFunction object of given dim and degree 
Thomas Witkowski's avatar
Thomas Witkowski committed
86
    BasisFunction(std::string name, int dim, int degree);
87

88
    /// destructor
89
90
91
    virtual ~BasisFunction();

  public:
92
    /// compares two BasisFunction objects.
Thomas Witkowski's avatar
Thomas Witkowski committed
93
94
    virtual bool operator==(const BasisFunction& a) const 
    {
95
      return a.getName() == name;
96
    }
97

98
    /// Returns !(*this == b)
Thomas Witkowski's avatar
Thomas Witkowski committed
99
100
    inline bool operator!=(const BasisFunction& b) const 
    {
101
      return !(operator == (b));
102
    }
103

104
    /// Used by \ref getDOFIndices and \ref getVec
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
    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
126
127
128
129
130
131
132
133
134
     * 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;
135
     */
136
    virtual void getBound(const ElInfo*, BoundaryType *) const {}
137

Thomas Witkowski's avatar
Thomas Witkowski committed
138
    /// Returns \ref degree of BasisFunction
Thomas Witkowski's avatar
Thomas Witkowski committed
139
140
    inline const int getDegree() const 
    { 
141
      return degree; 
142
    }
143

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

Thomas Witkowski's avatar
Thomas Witkowski committed
150
    /// Returns \ref nBasFcts which is the number of local basis functions
Thomas Witkowski's avatar
Thomas Witkowski committed
151
152
    inline const int getNumber() const 
    { 
153
      return nBasFcts; 
154
    }
155

Thomas Witkowski's avatar
Thomas Witkowski committed
156
    /// Returns \ref name of BasisFunction
Thomas Witkowski's avatar
Thomas Witkowski committed
157
    inline std::string getName() const 
Thomas Witkowski's avatar
Thomas Witkowski committed
158
    { 
159
      return name; 
160
    }
161

Thomas Witkowski's avatar
Thomas Witkowski committed
162
    /// Returns \ref nDOF[i]
163
164
    int getNumberOfDOFs(int i) const;

Thomas Witkowski's avatar
Thomas Witkowski committed
165
    /// Returns \ref nDOF
Thomas Witkowski's avatar
Thomas Witkowski committed
166
167
    inline DimVec<int>* getNumberOfDOFs() const 
    { 
168
      return nDOF; 
169
    }
170

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

Thomas Witkowski's avatar
Thomas Witkowski committed
174
    /// Returns the barycentric coordinates of the i-th basis function.
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
    virtual DimVec<double> *getCoords(int i) const = 0;

    /** \brief
     * Returns a pointer to a const vector with interpolation coefficients of the
     * 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.
     */
    virtual const double* interpol(const ElInfo *el_info, 
				   int n, const int *indices, 
				   AbstractFunction<double, WorldVector<double> > *f,
				   double *coeff) = 0;

199
    /// WorldVector<double> valued interpol function.
200
201
202
203
204
    virtual const WorldVector<double>* interpol(const ElInfo *el_info, int no, 
						const int *b_no,
						AbstractFunction<WorldVector<double>,
						             WorldVector<double> > *f, 
						WorldVector<double> *vec) = 0;
205

206
    /// Returns the i-th local basis function
Thomas Witkowski's avatar
Thomas Witkowski committed
207
208
    inline BasFctType *getPhi(int i) const 
    { 
209
      return (*phi)[i]; 
210
    }
211

212
    /// Returns the gradient of the i-th local basis function
Thomas Witkowski's avatar
Thomas Witkowski committed
213
214
    inline GrdBasFctType *getGrdPhi(int i) const 
    { 
215
      return (*grdPhi)[i]; 
216
    }
217

218
    /// Returns the second derivative of the i-th local basis function
Thomas Witkowski's avatar
Thomas Witkowski committed
219
220
    inline D2BasFctType *getD2Phi(int i) const 
    { 
221
      return (*d2Phi)[i]; 
222
    }
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

    /** \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*/,
246
247
			     DOFVector<double>* /*fh*/)
    {}
248

249
    /// WorldVector<double> valued l2ScpFctBas function
250
251
    virtual void l2ScpFctBas(Quadrature* ,
			     AbstractFunction<WorldVector<double>, WorldVector<double> >* /*f*/,
252
253
			     DOFVector<WorldVector<double> >* /*fh*/) 
    {}
254
255


256
257
    /// Interpolates a DOFIndexed<double> after refinement
    virtual void refineInter(DOFIndexed<double> *, RCNeighbourList*, int)
258
    {}
259

260
261
    /// Interpolates a DOFIndexed<double> after coarsening
    virtual void coarseInter(DOFIndexed<double> *, RCNeighbourList*, int)
262
    {}
263

264
265
    /// Restricts a DOFIndexed<double> after coarsening
    virtual void coarseRestr(DOFIndexed<double> *, RCNeighbourList*, int)
266
    {}
267

268
269
    /// Interpolates a DOFVector<WorldVector<double> > after refinement
    virtual void refineInter(DOFVector<WorldVector<double> >*, RCNeighbourList*, int)
270
    {}
271

272
273
    /// Interpolates a DOFVector<WorldVector<double> > after coarsening
    virtual void coarseInter(DOFVector<WorldVector<double> >*, RCNeighbourList*, int)
274
    {}
275

276
277
    /// Restricts a DOFVector<WorldVector<double> > after coarsening
    virtual void coarseRestr(DOFVector<WorldVector<double> >*, RCNeighbourList*, int)
278
    {}
279

280
    /// Returns local dof indices of the element for the given fe space.
Thomas Witkowski's avatar
Thomas Witkowski committed
281
282
283
    virtual const DegreeOfFreedom *getLocalIndices(const Element *el,
						   const DOFAdmin *admin,
						   DegreeOfFreedom *dofPtr) const
284
285
    {
      return NULL;
286
    }
287

288
    /// Returns local dof indices of the element for the given fe space.
Thomas Witkowski's avatar
Thomas Witkowski committed
289
290
291
292
293
294
295
296
    virtual void getLocalIndicesVec(const Element *el,
				    const DOFAdmin *admin,
				    Vector<DegreeOfFreedom> *ve) const
    {}

    virtual void getLocalDofPtrVec(const Element *el, 
				   const DOFAdmin *admin,
				   std::vector<const DegreeOfFreedom*>& vec) const
297
    {}
Thomas Witkowski's avatar
Thomas Witkowski committed
298

299
300
301
302
303
304

    /** \brief
     * Evaluates elements value at barycentric coordinates lambda with local 
     * coefficient vector uh.
     */
    double evalUh(const DimVec<double>& lambda, const double* uh) const;
305

306
307
308
309
310
311
312
    /** \brief
     * Evaluates elements value at barycentric coordinates lambda with local 
     * coefficient vector uh. 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 WorldVector<double>& evalUh(const DimVec<double>& lambda, 
313
314
				      const WorldVector<double>* uh, 
				      WorldVector<double>* val) const;
315

316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
    /** \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.
     */
    const WorldVector<double>& evalGrdUh(const DimVec<double>& lambda,
					 const DimVec<WorldVector<double> >& Lambda,
					 const double* uh,  WorldVector<double>* val) const;

    /** \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,
					const double* uh, WorldMatrix<double>* val) const;

  protected:
339
    /// Textual description
340
    std::string name;     
341

342
    /// Number of basisfunctions on one Element                 
343
344
    int nBasFcts;

345
    /// Maximal degree of the basis functions                 
346
347
    int degree;

348
    /// Dimension of the basis functions                  
349
350
    int dim;

351
    /// Dimension of the world.
Thomas Witkowski's avatar
Thomas Witkowski committed
352
353
    int dow;

354
    /// Number of DOFs at the different positions                  
355
356
    DimVec<int> *nDOF;

357
    /// Vector of the local functions
358
    std::vector<BasFctType*> *phi;
359

360
    /// Vector of gradients
361
    std::vector<GrdBasFctType*> *grdPhi;
362

363
    /// Vector of second derivatives
364
    std::vector<D2BasFctType*> *d2Phi;
Thomas Witkowski's avatar
Thomas Witkowski committed
365
366
367
368
369

    /** \brief
     * Is used by function evalGrdUh. To make it thread safe, we need a
     * temporary DimVec for every thread.
     */
370
    std::vector<DimVec<double>* > grdTmpVec1;
Thomas Witkowski's avatar
Thomas Witkowski committed
371
372
373
374
375

    /** \brief
     * Is used by function evalGrdUh. To make it thread safe, we need a
     * temporary DimVec for every thread.
     */
376
    std::vector<DimVec<double>* > grdTmpVec2;
377
378
379
380
381
  };

}

#endif  // AMDIS_BASISFUNCTION_H