Peter Gottschling committed Feb 15, 2008 1 2 3 4 5 6 // ============================================================================ // == == // == AMDiS - Adaptive multidimensional simulations == // == == // ============================================================================ // == ==  Thomas Witkowski committed Sep 28, 2009 7 // == TU Dresden ==  Peter Gottschling committed Feb 15, 2008 8 // == ==  Thomas Witkowski committed Sep 28, 2009 9 10 11 // == Institut fr Wissenschaftliches Rechnen == // == Zellescher Weg 12-14 == // == 01069 Dresden ==  Peter Gottschling committed Feb 15, 2008 12 13 14 15 // == germany == // == == // ============================================================================ // == ==  Thomas Witkowski committed Sep 28, 2009 16 // == https://gforge.zih.tu-dresden.de/projects/amdis/ ==  Peter Gottschling committed Feb 15, 2008 17 18 19 20 21 22 23 24 // == == // ============================================================================ /** \file Quadrature.h */ #ifndef AMDIS_QUADRATURE_H #define AMDIS_QUADRATURE_H  Thomas Witkowski committed May 12, 2009 25 26 #include #include "AMDiS_fwd.h"  Peter Gottschling committed Feb 15, 2008 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 #include "BasisFunction.h" #include "Flag.h" #include "FixVec.h" namespace AMDiS { /** * \ingroup Assembler * * \brief * For the assemblage of the system matrix and right hand side vector of the * linear system, we have to compute integrals, for example: * \f[ \int_{\Omega} f(x)\varphi_i(x) dx \f] * For general data A, b, c, and f, these integrals can not be calculated * exactly. Quadrature formulas have to be used in order to calculate the * integrals approximately. Numerical integration in finite element methods is * done by looping over all grid elements and using a quadrature formula on * each element. */ class Quadrature { protected:  Thomas Witkowski committed Jul 03, 2009 49  /// Avoids call of default constructor  Peter Gottschling committed Feb 15, 2008 50 51 52 53 54 55 56 57 58  Quadrature(); /** \brief * Constructs a Quadrature with name name_ of degree degree_ for dim dim_. * The Quadrature has n_points_ quadrature points with barycentric * coordinates lambda_ and weights w_. The constructor is protected because * access to a Quadrature should be done via \ref provideQuadrature. */ Quadrature(const char* name_,  Thomas Witkowski committed Jun 20, 2008 59 60 61  int degree_, int dim_, int n_points_,  Peter Gottschling committed Feb 15, 2008 62  VectorOfFixVecs > *lambda_,  Thomas Witkowski committed Jun 20, 2008 63  double* w_)  Peter Gottschling committed Feb 15, 2008 64 65 66 67 68 69  : name(name_), degree(degree_), dim(dim_), n_points(n_points_), lambda(lambda_), w(w_)  Thomas Witkowski committed Oct 09, 2008 70  {}  Peter Gottschling committed Feb 15, 2008 71 72  public:  Thomas Witkowski committed Mar 23, 2009 73  /// Copy constructor  Peter Gottschling committed Feb 15, 2008 74 75  Quadrature(const Quadrature&);  Thomas Witkowski committed Mar 23, 2009 76  /// Destructor  Thomas Witkowski committed Sep 09, 2008 77 78  ~Quadrature();  Thomas Witkowski committed Mar 23, 2009 79  /// Returns a Quadrature for dimension dim exact for degree degree.  Thomas Witkowski committed Sep 02, 2008 80  static Quadrature *provideQuadrature(int dim, int degree);  Peter Gottschling committed Feb 15, 2008 81 82 83 84 85 86 87 88 89 90 91 92 93  /** \brief * Approximates an integral by the numerical quadrature described by quad; * f is a pointer to an AbstractFunction to be integrated, evaluated in * barycentric coordinates; the return value is * \f[ \sum_{k = 0}^{n_points-1} w[k] * (*f)(lambda[k]) \f] * For the approximation of \f$\int_S f\f$ we have to multiply this value * with d!|S| for a simplex S; for a parametric simplex f should be a pointer * to a function which calculates * \f$f(\lambda)|det DF_S(\hat{x}(\lambda))| \f$. */ double integrateStdSimplex(AbstractFunction > *f);  Thomas Witkowski committed Jul 03, 2009 94  /// Returns \ref name  Thomas Witkowski committed Jul 20, 2009 95  inline std::string getName()  Thomas Witkowski committed Jul 03, 2009 96  {  Thomas Witkowski committed May 07, 2008 97  return name;  Thomas Witkowski committed Mar 23, 2009 98  }  Peter Gottschling committed Feb 15, 2008 99   Thomas Witkowski committed Mar 23, 2009 100  /// Returns \ref n_points  Thomas Witkowski committed Jul 03, 2009 101 102  inline int getNumPoints() const {  Thomas Witkowski committed May 07, 2008 103  return n_points;  Thomas Witkowski committed Mar 23, 2009 104  }  Peter Gottschling committed Feb 15, 2008 105   Thomas Witkowski committed Jul 03, 2009 106 107 108  /// Returns \ref w[p] inline double getWeight(int p) const {  Thomas Witkowski committed May 07, 2008 109  return w[p];  Thomas Witkowski committed Mar 23, 2009 110  }  Peter Gottschling committed Feb 15, 2008 111   Thomas Witkowski committed Jul 03, 2009 112 113 114  /// Returns \ref w. inline double* getWeight() const {  Thomas Witkowski committed May 07, 2008 115  return w;  Thomas Witkowski committed Mar 23, 2009 116  }  Peter Gottschling committed Feb 15, 2008 117   Thomas Witkowski committed Jul 03, 2009 118 119 120  /// Returns \ref dim inline int getDim() const {  Thomas Witkowski committed May 07, 2008 121  return dim;  Thomas Witkowski committed Mar 23, 2009 122  }  Peter Gottschling committed Feb 15, 2008 123   Thomas Witkowski committed Jul 03, 2009 124 125 126  /// Returns \ref degree inline int getDegree() const {  Thomas Witkowski committed May 07, 2008 127  return degree;  Thomas Witkowski committed Mar 23, 2009 128  }  Peter Gottschling committed Feb 15, 2008 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158  /** \brief * Returns a pointer to a vector storing the values of a doubled valued * function at all quadrature points; f is that AbstractFunction * , evaluated in barycentric coordinates; if vec is not NULL, the values are * stored in this vector, otherwise the values are stored in some static * local vector, which is overwritten on the next call */ const double *fAtQp(const AbstractFunction >& f, double *vec) const ; /** \brief * Returns a pointer to a vector storing the gradient (with respect to world * coordinates) of a double valued function at all quadrature points; * grdF is a pointer to a AbstractFunction, evaluated in barycentric * coordinates and returning a pointer to a WorldVector storing the gradient; * if vec is not NULL, the values are stored in this vector, otherwise the * values are stored in some local static vector, which is overwritten on the * next call */ const WorldVector *grdFAtQp(const AbstractFunction, DimVec >& grdF, WorldVector* vec) const; /** \brief * Returns \ref lambda[a][b] which is the b-th coordinate entry of the a-th * quadrature point */  Thomas Witkowski committed Jul 03, 2009 159 160  inline double getLambda(int a, int b) const {  Peter Gottschling committed Feb 15, 2008 161  return (lambda ? (*lambda)[a][b] : 0.0);  Thomas Witkowski committed Mar 23, 2009 162  }  Peter Gottschling committed Feb 15, 2008 163 164 165 166 167  /** \brief * Returns \ref lambda[a] which is a DimVec containing the * coordiantes of the a-th quadrature point */  Thomas Witkowski committed Jul 03, 2009 168 169  inline const DimVec& getLambda(int a) const {  Peter Gottschling committed Feb 15, 2008 170  return (*lambda)[a];  Thomas Witkowski committed Mar 23, 2009 171  }  Peter Gottschling committed Feb 15, 2008 172   Thomas Witkowski committed Jul 03, 2009 173 174 175  /// Returns \ref lambda which is a VectorOfFixvecs >. VectorOfFixVecs > *getLambda() const {  Thomas Witkowski committed May 07, 2008 176  return lambda;  Thomas Witkowski committed Mar 23, 2009 177  }  Peter Gottschling committed Feb 15, 2008 178 179 180  public:  Thomas Witkowski committed Jul 03, 2009 181  /// Maximal number of quadrature points for the different dimensions  Peter Gottschling committed Feb 15, 2008 182 183 184  static const int maxNQuadPoints[4]; protected:  Thomas Witkowski committed Jul 03, 2009 185  /// Name of this Quadrature  Thomas Witkowski committed Aug 21, 2008 186  std::string name;  Peter Gottschling committed Feb 15, 2008 187   Thomas Witkowski committed Jul 03, 2009 188  /// Quadrature is exact of this degree  Peter Gottschling committed Feb 15, 2008 189 190  int degree;  Thomas Witkowski committed Jul 03, 2009 191  /// Quadrature for dimension dim  Peter Gottschling committed Feb 15, 2008 192 193  int dim;  Thomas Witkowski committed Mar 23, 2009 194  /// Number of quadrature points  Peter Gottschling committed Feb 15, 2008 195 196  int n_points;  Thomas Witkowski committed Jul 03, 2009 197  /// Vector of quadrature points given in barycentric coordinates  Peter Gottschling committed Feb 15, 2008 198 199  VectorOfFixVecs > *lambda;  Thomas Witkowski committed Jul 03, 2009 200  /// Vector of quadrature weights  Peter Gottschling committed Feb 15, 2008 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283  double *w; protected: /** \brief * Initialisation of all static Quadrature objects which will be returned * by \ref provideQuadrature() */ static void initStaticQuadratures(); /** \name static quadratures, used weights, and barycentric coords * \{ */ static Quadrature **quad_nd[4]; static Quadrature *quad_0d[1]; static Quadrature *quad_1d[20]; static Quadrature *quad_2d[18]; static Quadrature *quad_3d[8]; static VectorOfFixVecs > *x_0d; static double *w_0d; static VectorOfFixVecs > *x0_1d; static VectorOfFixVecs > *x1_1d; static VectorOfFixVecs > *x2_1d; static VectorOfFixVecs > *x3_1d; static VectorOfFixVecs > *x4_1d; static VectorOfFixVecs > *x5_1d; static VectorOfFixVecs > *x6_1d; static VectorOfFixVecs > *x7_1d; static VectorOfFixVecs > *x8_1d; static VectorOfFixVecs > *x9_1d; static double *w0_1d; static double *w1_1d; static double *w2_1d; static double *w3_1d; static double *w4_1d; static double *w5_1d; static double *w6_1d; static double *w7_1d; static double *w8_1d; static double *w9_1d; static VectorOfFixVecs > *x1_2d; static VectorOfFixVecs > *x2_2d; static VectorOfFixVecs > *x3_2d; static VectorOfFixVecs > *x4_2d; static VectorOfFixVecs > *x5_2d; static VectorOfFixVecs > *x7_2d; static VectorOfFixVecs > *x8_2d; static VectorOfFixVecs > *x9_2d; static VectorOfFixVecs > *x10_2d; static VectorOfFixVecs > *x11_2d; static VectorOfFixVecs > *x12_2d; static VectorOfFixVecs > *x17_2d; static double *w1_2d; static double *w2_2d; static double *w3_2d; static double *w4_2d; static double *w5_2d; static double *w7_2d; static double *w8_2d; static double *w9_2d; static double *w10_2d; static double *w11_2d; static double *w12_2d; static double *w17_2d; static VectorOfFixVecs > *x1_3d; static VectorOfFixVecs > *x2_3d; static VectorOfFixVecs > *x3_3d; static VectorOfFixVecs > *x4_3d; static VectorOfFixVecs > *x5_3d; static VectorOfFixVecs > *x7_3d; static double *w1_3d; static double *w2_3d; static double *w3_3d; static double *w4_3d; static double *w5_3d; static double *w7_3d; /** \} */ };  Thomas Witkowski committed Jul 03, 2009 284   Peter Gottschling committed Feb 15, 2008 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335  /** \brief * Pre-compute the values of all basis functions at all quadrature nodes; */ const Flag INIT_PHI=1; /** \brief * Pre-compute the gradients (with respect to the barycentric coordinates) of * all basis functions at all quadrature nodes */ const Flag INIT_GRD_PHI=2; /** \brief * pre-compute all 2nd derivatives (with respect to the barycentric * coordinates) of all basis functions at all quadrature nodes; */ const Flag INIT_D2_PHI=4; /** * \ingroup Integration * *\brief * Often numerical integration involves basis functions, such as the assembling * of the system matrix and right hand side, or the integration of finite * element functions. Since numerical quadrature involves only the values at * the quadrature points and the values of basis functions and its derivatives * are the same at these points for all elements of the grid, such routines can * be much more efficient, if they can use pre-computed values of the basis * functions at the quadrature points. In this case the basis functions do not * have to be evaluated for each quadrature point on every element newly. * Information that should be pre-computed can be specified by the following * symbolic constants: * \ref INIT_PHI, \ref INIT_GRD_PHI, \ref INIT_D2_PHI */ class FastQuadrature { protected: /** \brief * Constructs a FastQuadrature for the given Quadrature, BasisFunction, and * flag. */ FastQuadrature(BasisFunction* basFcts, Quadrature* quad, Flag flag) : init_flag(flag), phi(NULL), grdPhi(NULL), D2Phi(NULL), quadrature(quad), basisFunctions(basFcts)  Thomas Witkowski committed Mar 23, 2009 336  {}  Peter Gottschling committed Feb 15, 2008 337   Thomas Witkowski committed Jul 03, 2009 338  /// Copy constructor  Peter Gottschling committed Feb 15, 2008 339 340  FastQuadrature(const FastQuadrature&);  Thomas Witkowski committed Jul 03, 2009 341  /// Extended copy constructor  Thomas Witkowski committed Jun 20, 2008 342  FastQuadrature(const FastQuadrature&, const Flag);  Peter Gottschling committed Feb 15, 2008 343   Thomas Witkowski committed Jul 03, 2009 344  /// Destructor  Peter Gottschling committed Feb 15, 2008 345 346 347  ~FastQuadrature(); public:  Thomas Witkowski committed Jul 03, 2009 348  /// Returns a FastQuadrature for the given BasisFunction, Quadrature, and flags.  Peter Gottschling committed Feb 15, 2008 349 350 351 352  static FastQuadrature* provideFastQuadrature(const BasisFunction*, const Quadrature&, Flag);  Thomas Witkowski committed Jul 03, 2009 353  /// inits FastQuadrature like speciefied in flag  Peter Gottschling committed Feb 15, 2008 354 355  void init(Flag init_flag);  Thomas Witkowski committed Jul 03, 2009 356 357 358  inline bool initialized(Flag flag) { if (flag == INIT_PHI)  Peter Gottschling committed Feb 15, 2008 359 360  return (phi != NULL);  Thomas Witkowski committed Jul 03, 2009 361  if (flag == INIT_GRD_PHI)  Peter Gottschling committed Feb 15, 2008 362 363  return (grdPhi != NULL);  Thomas Witkowski committed Jul 03, 2009 364  if (flag == INIT_D2_PHI)  Peter Gottschling committed Feb 15, 2008 365 366 367 368  return (D2Phi != NULL); ERROR_EXIT("invalid flag\n"); return false;  Thomas Witkowski committed Mar 23, 2009 369  }  Peter Gottschling committed Feb 15, 2008 370   Thomas Witkowski committed Jul 03, 2009 371 372 373  /// Returns \ref quadrature inline const Quadrature* getQuadrature() const {  Thomas Witkowski committed May 20, 2008 374  return quadrature;  Thomas Witkowski committed Mar 23, 2009 375  }  Peter Gottschling committed Feb 15, 2008 376   Thomas Witkowski committed Jul 03, 2009 377 378 379  /// Returns \ref max_points inline int getMaxQuadPoints() {  Thomas Witkowski committed May 20, 2008 380  return max_points;  Thomas Witkowski committed Mar 23, 2009 381  }  Peter Gottschling committed Feb 15, 2008 382   Thomas Witkowski committed Jul 03, 2009 383  /// Returns (*\ref D2Phi)[q][i][j][m]  Thomas Witkowski committed Jun 20, 2008 384  const double getSecDer(int q, int i, int j, int m) const;  Peter Gottschling committed Feb 15, 2008 385   Thomas Witkowski committed Jul 03, 2009 386  /// Returns (*\ref D2Phi)[q]  Peter Gottschling committed Feb 15, 2008 387 388  const VectorOfFixVecs > *getSecDer(int q) const;  Thomas Witkowski committed Jul 03, 2009 389 390 391  /// Returns (*\ref grdPhi)[q][i][j] inline const double getGradient(int q, int i ,int j) const {  Thomas Witkowski committed Aug 21, 2008 392  return (grdPhi) ? (*grdPhi)[q][i][j] : 0.0;  Thomas Witkowski committed Mar 23, 2009 393  }  Peter Gottschling committed Feb 15, 2008 394   Thomas Witkowski committed Jul 03, 2009 395 396 397  /// Returns (*\ref grdPhi)[q] inline VectorOfFixVecs >* getGradient(int q) const {  Thomas Witkowski committed Aug 21, 2008 398  return (grdPhi) ? &((*grdPhi)[q]) : NULL;  Thomas Witkowski committed Mar 23, 2009 399  }  Peter Gottschling committed Feb 15, 2008 400   Thomas Witkowski committed Nov 17, 2009 401 402 403 404 405  inline DimVec& getGradient(int q, int i) const { return (*grdPhi)[q][i]; }  Thomas Witkowski committed Jul 03, 2009 406 407 408  /// Returns \ref phi[q][i] inline const double getPhi(int q, int i) const {  Thomas Witkowski committed Jun 20, 2008 409  return (phi) ? phi[q][i] : 0.0;  Thomas Witkowski committed Mar 23, 2009 410  }  Peter Gottschling committed Feb 15, 2008 411   Thomas Witkowski committed Jul 03, 2009 412 413 414  /// Returns \ref phi[q] inline const double *getPhi(int q) const {  Thomas Witkowski committed Jun 20, 2008 415  return (phi) ? phi[q] : NULL;  Thomas Witkowski committed Mar 23, 2009 416  }  Peter Gottschling committed Feb 15, 2008 417   Thomas Witkowski committed Jul 03, 2009 418 419 420  /// Returns \ref quadrature ->integrateStdSimplex(f) inline double integrateStdSimplex(AbstractFunction > *f) {  Peter Gottschling committed Feb 15, 2008 421  return quadrature->integrateStdSimplex(f);  Thomas Witkowski committed Mar 23, 2009 422  }  Peter Gottschling committed Feb 15, 2008 423   Thomas Witkowski committed Jul 03, 2009 424 425 426  /// Returns \ref quadrature ->getNumPoints() inline int getNumPoints() const {  Thomas Witkowski committed Jun 20, 2008 427  return quadrature->getNumPoints();  Thomas Witkowski committed Mar 23, 2009 428  }  Peter Gottschling committed Feb 15, 2008 429   Thomas Witkowski committed Jul 03, 2009 430 431 432  /// Returns \ref quadrature ->getWeight(p) inline double getWeight(int p) const {  Thomas Witkowski committed Jun 20, 2008 433  return quadrature->getWeight(p);  Thomas Witkowski committed Mar 23, 2009 434  }  Peter Gottschling committed Feb 15, 2008 435   Thomas Witkowski committed Jul 03, 2009 436 437 438  /// Returns \ref quadrature ->getDim() inline int getDim() const {  Thomas Witkowski committed Jun 20, 2008 439  return quadrature->getDim();  Thomas Witkowski committed Mar 23, 2009 440  }  Peter Gottschling committed Feb 15, 2008 441   Thomas Witkowski committed Jul 03, 2009 442 443 444  /// Returns \ref quadrature ->getDegree() inline int getDegree() const {  Thomas Witkowski committed Jun 20, 2008 445  return quadrature->getDegree();  Thomas Witkowski committed Mar 23, 2009 446  }  Peter Gottschling committed Feb 15, 2008 447   Thomas Witkowski committed Jul 03, 2009 448  /// Returns \ref quadrature ->grdFAtQp(f, vec)  Peter Gottschling committed Feb 15, 2008 449 450 451 452 453 454  inline const WorldVector *grdFAtQp(const AbstractFunction, DimVec >& f, WorldVector* vec) const { return quadrature->grdFAtQp(f, vec);  Thomas Witkowski committed Mar 23, 2009 455  }  Peter Gottschling committed Feb 15, 2008 456   Thomas Witkowski committed Jul 03, 2009 457  /// Returns \ref quadrature ->fAtQp(f, vec)  Peter Gottschling committed Feb 15, 2008 458  inline const double *fAtQp(const AbstractFunction >& f, double *vec) const  Peter Gottschling committed Feb 15, 2008 460 461  { return quadrature->fAtQp(f, vec);  Thomas Witkowski committed Mar 23, 2009 462  }  Peter Gottschling committed Feb 15, 2008 463   Thomas Witkowski committed Jul 03, 2009 464 465 466  /// Returns \ref quadrature ->getLambda(a,b) inline double getLambda(int a,int b) const {  Peter Gottschling committed Feb 15, 2008 467  return quadrature->getLambda(a,b);  Thomas Witkowski committed Mar 23, 2009 468  }  Peter Gottschling committed Feb 15, 2008 469   Thomas Witkowski committed Jul 03, 2009 470 471 472  /// Returns \ref quadrature ->getLambda(a) inline const DimVec& getLambda(int a) const {  Peter Gottschling committed Feb 15, 2008 473  return quadrature->getLambda(a);  Thomas Witkowski committed Mar 23, 2009 474  }  Peter Gottschling committed Feb 15, 2008 475   Thomas Witkowski committed Jul 03, 2009 476 477 478  /// Returns \ref basisFunctions inline BasisFunction* getBasisFunctions() const {  Thomas Witkowski committed May 20, 2008 479  return basisFunctions;  Thomas Witkowski committed Mar 23, 2009 480  }  Peter Gottschling committed Feb 15, 2008 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517  protected: /** \brief * Specifies which information should be pre-computed. Can be \ref INIT_PHI, * \ref INIT_GRD_PHI, or \ref INIT_D2_PHI */ Flag init_flag; /** \brief * Matrix storing function values if the flag \ref INIT_PHI is set; * phi[i][j] stores the value \ref basisFunctions->phi[j] * (quadrature->lambda[i]), 0 <= j < basisFunctions->getNumber() and * 0 <= i < n_points */ double **phi; /** \brief * Matrix storing all gradients (with respect to the barycentric coordinates) * if the flag \ref INIT_GRD_PHI is set; grdPhi[i][j][k] stores the value * basisFunctions->grdPhi[j](quadrature->lambda[i])[k] * for 0 <= j < basisFunctions->getNumber(), * 0 <= i < . . . , n_points, and 0 <= k < DIM */ MatrixOfFixVecs > *grdPhi; /** \brief * Matrix storing all second derivatives (with respect to the barycentric * coordinates) if the flag \ref INIT_D2_PHI is set; D2Phi[i][j][k][l] stores * the value basisFunctions->D2Phi[j](quadrature->lambda[i])[k][l] * for 0 <= j < basisFunctions->getNumber(), * 0 <= i < n_points, and 0 <= k,l < DIM */ MatrixOfFixVecs > *D2Phi; /** \brief * List of all used FastQuadratures */  Thomas Witkowski committed Aug 21, 2008 518  static std::list fastQuadList;  Peter Gottschling committed Feb 15, 2008 519 520 521 522 523 524 525 526  /** \brief * Maximal number of quadrature points for all yet initialised FastQuadrature * objects. This value may change after a new initialisation of a * FastQuadrature */ static int max_points;  Thomas Witkowski committed Jul 03, 2009 527  /// This FastQuadrature stores values for Quadrature quadrature  Peter Gottschling committed Feb 15, 2008 528 529  Quadrature* quadrature;  Thomas Witkowski committed Jul 03, 2009 530  /// Values stored for basis functions basisFunctions  Peter Gottschling committed Feb 15, 2008 531 532 533 534 535 536 537  BasisFunction* basisFunctions; }; } #endif // AMDIS_QUADRATURE_H