Quadrature.h 15.4 KB
Newer Older
 Peter Gottschling committed Feb 15, 2008 1 2 3 4 // ============================================================================ // == == // == AMDiS - Adaptive multidimensional simulations == // == ==  Thomas Witkowski committed Dec 16, 2010 5 // == http://www.amdis-fem.org ==  Peter Gottschling committed Feb 15, 2008 6 7 // == == // ============================================================================  Thomas Witkowski committed Dec 16, 2010 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.  Peter Gottschling committed Feb 15, 2008 20 21 22 23 24 25  /** \file Quadrature.h */ #ifndef AMDIS_QUADRATURE_H #define AMDIS_QUADRATURE_H  Thomas Witkowski committed May 12, 2009 26 #include  Thomas Witkowski committed Feb 24, 2011 27 28 #include #include  Thomas Witkowski committed May 12, 2009 29 #include "AMDiS_fwd.h"  Peter Gottschling committed Feb 15, 2008 30 31 32 33 34 35 #include "BasisFunction.h" #include "Flag.h" #include "FixVec.h" namespace AMDiS {  Thomas Witkowski committed Feb 24, 2011 36 37  using namespace std;  Peter Gottschling committed Feb 15, 2008 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53  /** * \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 54  /// Avoids call of default constructor  Peter Gottschling committed Feb 15, 2008 55 56 57 58 59 60 61 62 63  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 64 65 66  int degree_, int dim_, int n_points_,  Peter Gottschling committed Feb 15, 2008 67  VectorOfFixVecs > *lambda_,  Thomas Witkowski committed Jun 20, 2008 68  double* w_)  Peter Gottschling committed Feb 15, 2008 69 70 71 72 73 74  : name(name_), degree(degree_), dim(dim_), n_points(n_points_), lambda(lambda_), w(w_)  Thomas Witkowski committed Oct 09, 2008 75  {}  Peter Gottschling committed Feb 15, 2008 76 77  public:  Thomas Witkowski committed Mar 23, 2009 78  /// Copy constructor  Peter Gottschling committed Feb 15, 2008 79 80  Quadrature(const Quadrature&);  Thomas Witkowski committed Mar 23, 2009 81  /// Destructor  Thomas Witkowski committed Sep 09, 2008 82 83  ~Quadrature();  Thomas Witkowski committed Mar 23, 2009 84  /// Returns a Quadrature for dimension dim exact for degree degree.  Thomas Witkowski committed Sep 02, 2008 85  static Quadrature *provideQuadrature(int dim, int degree);  Peter Gottschling committed Feb 15, 2008 86 87 88 89 90 91 92 93 94 95 96 97 98  /** \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 99  /// Returns \ref name  Thomas Witkowski committed Feb 24, 2011 100  inline string getName()  Thomas Witkowski committed Jul 03, 2009 101  {  Thomas Witkowski committed May 07, 2008 102  return name;  Thomas Witkowski committed Mar 23, 2009 103  }  Peter Gottschling committed Feb 15, 2008 104   Thomas Witkowski committed Mar 23, 2009 105  /// Returns \ref n_points  Thomas Witkowski committed Jul 03, 2009 106 107  inline int getNumPoints() const {  Thomas Witkowski committed May 07, 2008 108  return n_points;  Thomas Witkowski committed Mar 23, 2009 109  }  Peter Gottschling committed Feb 15, 2008 110   Thomas Witkowski committed Jul 03, 2009 111 112 113  /// Returns \ref w[p] inline double getWeight(int p) const {  Thomas Witkowski committed May 07, 2008 114  return w[p];  Thomas Witkowski committed Mar 23, 2009 115  }  Peter Gottschling committed Feb 15, 2008 116   Thomas Witkowski committed Jul 03, 2009 117 118 119  /// Returns \ref w. inline double* getWeight() const {  Thomas Witkowski committed May 07, 2008 120  return w;  Thomas Witkowski committed Mar 23, 2009 121  }  Peter Gottschling committed Feb 15, 2008 122   Thomas Witkowski committed Jul 03, 2009 123 124 125  /// Returns \ref dim inline int getDim() const {  Thomas Witkowski committed May 07, 2008 126  return dim;  Thomas Witkowski committed Mar 23, 2009 127  }  Peter Gottschling committed Feb 15, 2008 128   Thomas Witkowski committed Jul 03, 2009 129 130 131  /// Returns \ref degree inline int getDegree() const {  Thomas Witkowski committed May 07, 2008 132  return degree;  Thomas Witkowski committed Mar 23, 2009 133  }  Peter Gottschling committed Feb 15, 2008 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 159  /** \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;  160 161  /// Returns \ref lambda[a][b] which is the b-th coordinate entry of the a-th /// quadrature point  Thomas Witkowski committed Jul 03, 2009 162 163  inline double getLambda(int a, int b) const {  Peter Gottschling committed Feb 15, 2008 164  return (lambda ? (*lambda)[a][b] : 0.0);  Thomas Witkowski committed Mar 23, 2009 165  }  Peter Gottschling committed Feb 15, 2008 166   167 168  /// Returns \ref lambda[a] which is a DimVec containing the /// coordiantes of the a-th quadrature point  Thomas Witkowski committed Jul 03, 2009 169 170  inline const DimVec& getLambda(int a) const {  Peter Gottschling committed Feb 15, 2008 171  return (*lambda)[a];  Thomas Witkowski committed Mar 23, 2009 172  }  Peter Gottschling committed Feb 15, 2008 173   Thomas Witkowski committed Jul 03, 2009 174 175 176  /// Returns \ref lambda which is a VectorOfFixvecs >. VectorOfFixVecs > *getLambda() const {  Thomas Witkowski committed May 07, 2008 177  return lambda;  Thomas Witkowski committed Mar 23, 2009 178  }  Peter Gottschling committed Feb 15, 2008 179 180 181  public:  Thomas Witkowski committed Jul 03, 2009 182  /// Maximal number of quadrature points for the different dimensions  Peter Gottschling committed Feb 15, 2008 183 184 185  static const int maxNQuadPoints[4]; protected:  Thomas Witkowski committed Jul 03, 2009 186  /// Name of this Quadrature  Thomas Witkowski committed Feb 24, 2011 187  string name;  Peter Gottschling committed Feb 15, 2008 188   Thomas Witkowski committed Jul 03, 2009 189  /// Quadrature is exact of this degree  Peter Gottschling committed Feb 15, 2008 190 191  int degree;  Thomas Witkowski committed Jul 03, 2009 192  /// Quadrature for dimension dim  Peter Gottschling committed Feb 15, 2008 193 194  int dim;  Thomas Witkowski committed Mar 23, 2009 195  /// Number of quadrature points  Peter Gottschling committed Feb 15, 2008 196 197  int n_points;  Thomas Witkowski committed Jul 03, 2009 198  /// Vector of quadrature points given in barycentric coordinates  Peter Gottschling committed Feb 15, 2008 199 200  VectorOfFixVecs > *lambda;  Thomas Witkowski committed Jul 03, 2009 201  /// Vector of quadrature weights  Peter Gottschling committed Feb 15, 2008 202 203 204  double *w; protected:  205 206  /// Initialisation of all static Quadrature objects which will be returned /// by \ref provideQuadrature()  Peter Gottschling committed Feb 15, 2008 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  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 283   Peter Gottschling committed Feb 15, 2008 284   285  /// Pre-compute the values of all basis functions at all quadrature nodes;  Peter Gottschling committed Feb 15, 2008 286 287  const Flag INIT_PHI=1;  288 289  /// Pre-compute the gradients (with respect to the barycentric coordinates) of /// all basis functions at all quadrature nodes  Peter Gottschling committed Feb 15, 2008 290 291  const Flag INIT_GRD_PHI=2;  292 293  /// pre-compute all 2nd derivatives (with respect to the barycentric /// coordinates) of all basis functions at all quadrature nodes;  Peter Gottschling committed Feb 15, 2008 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315  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:  316 317  /// Constructs a FastQuadrature for the given Quadrature, BasisFunction, and /// flag.  318  FastQuadrature(BasisFunction* basFcts, Quadrature* quad, Flag flag)  Thomas Witkowski committed Feb 24, 2011 319 320  : init_flag(flag), phi(0, 0),  Peter Gottschling committed Feb 15, 2008 321 322 323  D2Phi(NULL), quadrature(quad), basisFunctions(basFcts)  Thomas Witkowski committed Mar 23, 2009 324  {}  Peter Gottschling committed Feb 15, 2008 325   Thomas Witkowski committed Jul 03, 2009 326  /// Copy constructor  Peter Gottschling committed Feb 15, 2008 327 328  FastQuadrature(const FastQuadrature&);  Thomas Witkowski committed Jul 03, 2009 329  /// Extended copy constructor  Thomas Witkowski committed Jun 20, 2008 330  FastQuadrature(const FastQuadrature&, const Flag);  Peter Gottschling committed Feb 15, 2008 331   Thomas Witkowski committed Jul 03, 2009 332  /// Destructor  Peter Gottschling committed Feb 15, 2008 333 334 335  ~FastQuadrature(); public:  Thomas Witkowski committed Jul 03, 2009 336  /// Returns a FastQuadrature for the given BasisFunction, Quadrature, and flags.  Peter Gottschling committed Feb 15, 2008 337 338 339 340  static FastQuadrature* provideFastQuadrature(const BasisFunction*, const Quadrature&, Flag);  Thomas Witkowski committed Jul 03, 2009 341  /// inits FastQuadrature like speciefied in flag  Peter Gottschling committed Feb 15, 2008 342 343  void init(Flag init_flag);  Thomas Witkowski committed Jul 03, 2009 344 345 346  inline bool initialized(Flag flag) { if (flag == INIT_PHI)  Thomas Witkowski committed Feb 24, 2011 347  return (num_rows(phi) > 0);  Peter Gottschling committed Feb 15, 2008 348   Thomas Witkowski committed Jul 03, 2009 349  if (flag == INIT_GRD_PHI)  Thomas Witkowski committed Feb 24, 2011 350  return (!grdPhi.empty());  Peter Gottschling committed Feb 15, 2008 351   Thomas Witkowski committed Jul 03, 2009 352  if (flag == INIT_D2_PHI)  Peter Gottschling committed Feb 15, 2008 353 354 355 356  return (D2Phi != NULL); ERROR_EXIT("invalid flag\n"); return false;  Thomas Witkowski committed Mar 23, 2009 357  }  Peter Gottschling committed Feb 15, 2008 358   Thomas Witkowski committed Jul 03, 2009 359 360 361  /// Returns \ref quadrature inline const Quadrature* getQuadrature() const {  Thomas Witkowski committed May 20, 2008 362  return quadrature;  Thomas Witkowski committed Mar 23, 2009 363  }  Peter Gottschling committed Feb 15, 2008 364   Thomas Witkowski committed Jul 03, 2009 365 366 367  /// Returns \ref max_points inline int getMaxQuadPoints() {  Thomas Witkowski committed May 20, 2008 368  return max_points;  Thomas Witkowski committed Mar 23, 2009 369  }  Peter Gottschling committed Feb 15, 2008 370   Thomas Witkowski committed Jul 03, 2009 371  /// Returns (*\ref D2Phi)[q][i][j][m]  Thomas Witkowski committed Jun 20, 2008 372  const double getSecDer(int q, int i, int j, int m) const;  Peter Gottschling committed Feb 15, 2008 373   Thomas Witkowski committed Jul 03, 2009 374  /// Returns (*\ref D2Phi)[q]  Peter Gottschling committed Feb 15, 2008 375 376  const VectorOfFixVecs > *getSecDer(int q) const;  Thomas Witkowski committed Jul 03, 2009 377 378 379  /// Returns (*\ref grdPhi)[q][i][j] inline const double getGradient(int q, int i ,int j) const {  Thomas Witkowski committed Feb 24, 2011 380  return (!grdPhi.empty()) ? grdPhi[q][i][j] : 0.0;  Thomas Witkowski committed Mar 23, 2009 381  }  Peter Gottschling committed Feb 15, 2008 382   Thomas Witkowski committed Jul 03, 2009 383  /// Returns (*\ref grdPhi)[q]  Thomas Witkowski committed Feb 24, 2011 384  inline const vector >& getGradient(int q) const  Thomas Witkowski committed Jul 03, 2009 385  {  Thomas Witkowski committed Feb 24, 2011 386  return grdPhi[q];  Thomas Witkowski committed Mar 23, 2009 387  }  Peter Gottschling committed Feb 15, 2008 388   Thomas Witkowski committed Feb 24, 2011 389  inline const mtl::dense_vector& getGradient(int q, int i) const  Thomas Witkowski committed Nov 17, 2009 390  {  Thomas Witkowski committed Feb 24, 2011 391  return grdPhi[q][i];  Thomas Witkowski committed Nov 17, 2009 392 393  }  Thomas Witkowski committed Feb 24, 2011 394  inline const mtl::dense2D& getPhi() const  Thomas Witkowski committed Jul 03, 2009 395  {  Thomas Witkowski committed Feb 24, 2011 396  return phi;  Thomas Witkowski committed Mar 23, 2009 397  }  Peter Gottschling committed Feb 15, 2008 398   Thomas Witkowski committed Feb 24, 2011 399 400  /// Returns \ref phi[q][i] inline const double getPhi(int q, int i) const  Thomas Witkowski committed Jul 03, 2009 401  {  Thomas Witkowski committed Feb 24, 2011 402  return phi[q][i];  Thomas Witkowski committed Mar 23, 2009 403  }  Peter Gottschling committed Feb 15, 2008 404   Thomas Witkowski committed Jul 03, 2009 405 406 407  /// Returns \ref quadrature ->integrateStdSimplex(f) inline double integrateStdSimplex(AbstractFunction > *f) {  Peter Gottschling committed Feb 15, 2008 408  return quadrature->integrateStdSimplex(f);  Thomas Witkowski committed Mar 23, 2009 409  }  Peter Gottschling committed Feb 15, 2008 410   Thomas Witkowski committed Jul 03, 2009 411 412 413  /// Returns \ref quadrature ->getNumPoints() inline int getNumPoints() const {  Thomas Witkowski committed Jun 20, 2008 414  return quadrature->getNumPoints();  Thomas Witkowski committed Mar 23, 2009 415  }  Peter Gottschling committed Feb 15, 2008 416   Thomas Witkowski committed Jul 03, 2009 417 418 419  /// Returns \ref quadrature ->getWeight(p) inline double getWeight(int p) const {  Thomas Witkowski committed Jun 20, 2008 420  return quadrature->getWeight(p);  Thomas Witkowski committed Mar 23, 2009 421  }  Peter Gottschling committed Feb 15, 2008 422   Thomas Witkowski committed Jul 03, 2009 423 424 425  /// Returns \ref quadrature ->getDim() inline int getDim() const {  Thomas Witkowski committed Jun 20, 2008 426  return quadrature->getDim();  Thomas Witkowski committed Mar 23, 2009 427  }  Peter Gottschling committed Feb 15, 2008 428   Thomas Witkowski committed Jul 03, 2009 429 430 431  /// Returns \ref quadrature ->getDegree() inline int getDegree() const {  Thomas Witkowski committed Jun 20, 2008 432  return quadrature->getDegree();  Thomas Witkowski committed Mar 23, 2009 433  }  Peter Gottschling committed Feb 15, 2008 434   Thomas Witkowski committed Jul 03, 2009 435  /// Returns \ref quadrature ->grdFAtQp(f, vec)  Peter Gottschling committed Feb 15, 2008 436 437 438 439 440 441  inline const WorldVector *grdFAtQp(const AbstractFunction, DimVec >& f, WorldVector* vec) const { return quadrature->grdFAtQp(f, vec);  Thomas Witkowski committed Mar 23, 2009 442  }  Peter Gottschling committed Feb 15, 2008 443   Thomas Witkowski committed Jul 03, 2009 444  /// Returns \ref quadrature ->fAtQp(f, vec)  Peter Gottschling committed Feb 15, 2008 445  inline const double *fAtQp(const AbstractFunction >& f, double *vec) const  Peter Gottschling committed Feb 15, 2008 447 448  { return quadrature->fAtQp(f, vec);  Thomas Witkowski committed Mar 23, 2009 449  }  Peter Gottschling committed Feb 15, 2008 450   Thomas Witkowski committed Jul 03, 2009 451 452 453  /// Returns \ref quadrature ->getLambda(a,b) inline double getLambda(int a,int b) const {  Peter Gottschling committed Feb 15, 2008 454  return quadrature->getLambda(a,b);  Thomas Witkowski committed Mar 23, 2009 455  }  Peter Gottschling committed Feb 15, 2008 456   Thomas Witkowski committed Jul 03, 2009 457 458 459  /// Returns \ref quadrature ->getLambda(a) inline const DimVec& getLambda(int a) const {  Peter Gottschling committed Feb 15, 2008 460  return quadrature->getLambda(a);  Thomas Witkowski committed Mar 23, 2009 461  }  Peter Gottschling committed Feb 15, 2008 462   Thomas Witkowski committed Jul 03, 2009 463 464 465  /// Returns \ref basisFunctions inline BasisFunction* getBasisFunctions() const {  Thomas Witkowski committed May 20, 2008 466  return basisFunctions;  Thomas Witkowski committed Mar 23, 2009 467  }  Peter Gottschling committed Feb 15, 2008 468 469  protected:  470 471  /// Specifies which information should be pre-computed. Can be \ref INIT_PHI, /// \ref INIT_GRD_PHI, or \ref INIT_D2_PHI  Peter Gottschling committed Feb 15, 2008 472 473 474 475 476 477 478 479  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 */  Thomas Witkowski committed Feb 24, 2011 480  mtl::dense2D phi;  Peter Gottschling committed Feb 15, 2008 481 482 483 484 485 486 487 488  /** \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 */  Thomas Witkowski committed Feb 24, 2011 489  vector > > grdPhi;  Peter Gottschling committed Feb 15, 2008 490 491 492 493 494 495 496 497 498 499  /** \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;  500  /// List of all used FastQuadratures  Thomas Witkowski committed Feb 24, 2011 501  static list fastQuadList;  Peter Gottschling committed Feb 15, 2008 502   503 504 505  /// Maximal number of quadrature points for all yet initialised FastQuadrature /// objects. This value may change after a new initialisation of a /// FastQuadrature  Peter Gottschling committed Feb 15, 2008 506 507  static int max_points;  Thomas Witkowski committed Jul 03, 2009 508  /// This FastQuadrature stores values for Quadrature quadrature  Peter Gottschling committed Feb 15, 2008 509 510  Quadrature* quadrature;  Thomas Witkowski committed Jul 03, 2009 511  /// Values stored for basis functions basisFunctions  Peter Gottschling committed Feb 15, 2008 512 513 514 515 516 517 518  BasisFunction* basisFunctions; }; } #endif // AMDIS_QUADRATURE_H