quad.hh

Go to the documentation of this file.
1 
6 #ifndef quad_hh
7 #define quad_hh
8 
9 #include <iostream>
10 #include <memory>
11 #include "basics/typedefs.hh"
12 #include "basics/outputOperator.hh"
14 #include "geometry/cell2D.hh"
15 #include "geometry/integral.hh"
16 #include "integration/quadRule.hh"
17 #include "space/hpMethod.hh"
18 #include "element.hh"
20 #include "integration/laguerre.hh"
21 
22 namespace hp2D {
23 
24  using concepts::Real;
25 
26  // ******************************************************** IntegrableQuad **
27 
32  public:
34 
40  inline concepts::Real2d chi(const Real x, const Real y) const {
41  return cell_.elemMap( concepts::Real2d(x,y) );
42  }
43 
45  inline concepts::MapReal2d jacobian(const Real x, const Real y) const
46  {
47  concepts::Quad2d* cell = dynamic_cast<concepts::Quad2d*>(&cell_);
49  concepts::MapReal2d jac = cell->jacobian(x, y);
50 
52  if(intRule_.get()->domain())
53  jac *= 0.5; // factor comes due to integration over [-1,1]^2
54 
55  return jac;
56  }
57 
60  const Real y) const
61  {
62  return jacobian(x, y).inverse();
63  }
64 
65  // Computes the second partial derivatives of the inverse of the Mapping.
66  inline concepts::MapReal2d inverseLaplace(const Real x, const Real y) const
67  {
68  // TODO: move up the inverseLaplace to QuadNd and then
69  // remove this assert and dynamic cast again
70  const concepts::Quad2d *cell = dynamic_cast<concepts::Quad2d*>(&cell_);
72 
73  concepts::MapReal2d invLap = cell->inverseLaplace(x,y);
74 
76  if(intRule_.get()->domain())
77  invLap *= 2;
78 
79  return invLap;
80  }
81 
82 
83 // /// Computes the determinant of the Jacobian
84 // inline Real jacobianDeterminant(const Real x, const Real y) const
85 // {
86 // return jacobian(x, y).determinant();
87 // }
88 
91  inline Real gramDeterminantRoot(const Real x, const Real y) const
92  {
93  Real gramian = cell_.gramDeterminantRoot(x,y);
94 
96  //if integration is not on [0,1]^2, we need to scale
97  if(intRule_.get()->domain())
98  gramian *= 0.25; // factor due to the integration over [-1,1]^2
99  return gramian;
100  }
101 
109  void setStrategy(const concepts::Quad2dSubdivision* strategy = 0)
110  throw(concepts::StrategyChange)
111  {
112  // TODO: move up the subdivision strategy to QuadNd and then
113  // remove this assert and dynamic cast again
114  concepts::Quad2d *cell = dynamic_cast<concepts::Quad2d*>(&cell_);
116  cell->setStrategy(strategy);
117  }
118 
123  {
124  // TODO: move up the subdivision strategy to QuadNd and then
125  // remove this assert and dynamic cast again
126  const concepts::Quad2d *cell = dynamic_cast<concepts::Quad2d*>(&cell_);
128  return cell->getStrategy();
129  }
130 
131  virtual bool quadraturePoint(uint i, intPoint& p, intFormType form = ZERO,
132  bool localCoord = false) const;
133 
134 
135  // Returns the integration rule
136  const concepts::QuadratureRule2d* const intRule() const { return intRule_.get(); }
137 
145  static std::unique_ptr<concepts::QuadRuleFactoryTensor2d>& factory() { return factory_; }
146 
150 
151  protected:
153  //std::unique_ptr<concepts::QuadratureRule1d> intX_;
154  // std::unique_ptr<concepts::QuadratureRule1d> intY_;
155  // Factory for the integration rule
156  //static concepts::QuadRuleFactory rule_;
157 
158  // integration rule
159  std::unique_ptr<concepts::QuadratureRule2d> intRule_;
160 
163 
164 
165  // factory for the integration rule, i.e tensored structural
166  static std::unique_ptr<concepts::QuadRuleFactoryTensor2d> factory_;
167  };
168 
169 
175  void setQuadrature(enum concepts::intRule rule, uint noP);
176 
177  // ************************************************************** BaseQuad **
178 
181  template<class F = Real>
182  class BaseQuad : public Element<F>, public IntegrableQuad {
183  public:
193  virtual ~BaseQuad();
194 
195  virtual const concepts::Quad& support() const { return cell_.connector(); }
196  virtual concepts::Real3d vertex(uint i) const { return cell_.vertex(i); }
197  virtual const concepts::QuadNd& cell() const { return cell_; }
198 
200  virtual const concepts::ElementGraphics<F>* graphics() const = 0;
201 
202  protected:
203  virtual std::ostream& info(std::ostream& os) const;
204  };
205 
206  // **************************************************** QuadShapeFunctions **
207 
214  public:
227 
230  inline const ushort* p() const { return p_; }
231 
233  inline const concepts::Karniadakis<1,0>* shpfctX() const {
234  return shpfctX_.get();
235  }
237  inline const concepts::Karniadakis<1,0>* shpfctY() const {
238  return shpfctY_.get(); }
239 
241  inline const concepts::Karniadakis<1,1>* shpfctDX() const {
242  return shpfctDX_.get(); }
244  inline const concepts::Karniadakis<1,1>* shpfctDY() const {
245  return shpfctDY_.get(); }
246  protected:
248  // void computeShapefunctions_(const concepts::QuadratureRule1d *intX,
249  // const concepts::QuadratureRule1d *intY);
250 
253 
254  private:
256  ushort p_[2];
258  std::unique_ptr<concepts::Karniadakis<1,0> > shpfctX_, shpfctY_;
260  std::unique_ptr<concepts::Karniadakis<1,1> > shpfctDX_, shpfctDY_;
261  };
262 
263  // ****************************************************************** Quad **
264 
271  template<class F = Real>
272  class Quad : public BaseQuad<F>, public QuadShapeFunctions {
273  public:
280  Quad(concepts::QuadNd& cell, const ushort* p,
282 
283  virtual ~Quad();
284 
285  virtual const concepts::ElementGraphics<F>* graphics() const;
290  void recomputeShapefunctions(const uint nq[2]);
291 
293  void edgeP(const uint i, const uint& p) {
294  edges_[i] = &p;
295  }
296  const uint edgeP(const uint i) const {
299  return *edges_[i];
300  }
301  protected:
302  virtual std::ostream& info(std::ostream& os) const;
303  private:
305  static std::unique_ptr<concepts::ElementGraphics<F> > graphics_;
307  const uint* edges_[4];
308  };
309 
310 
311  // ********************************************************** InfiniteQuad **
312 
317  class InfiniteQuad : public Element<Real> {
318  public:
327 
328  virtual ~InfiniteQuad();
329 
330  const concepts::Connector2& support() const { return cell_.connector(); }
331  concepts::Real3d vertex(uint i) const { return cell_.vertex(i); }
332  const concepts::InfiniteQuad2d& cell() const { return cell_; }
333 
336  inline const ushort* p() const { return p_; }
337 
340  { return intX_.get(); }
341 
344  { return intY_.get(); }
345 
352  static void setIntegrationRuleX(enum concepts::intRule rule, bool constant,
353  uint points);
354 
361  static void setIntegrationRuleY(bool constant, uint points,
362  const Real border);
363 
365  static void resetIntegrationRule();
366 
368  static std::string integrationRule();
369 
371  inline const concepts::Karniadakis<1,0>* shpfctX() const {
372  return shpfctX_.get();
373  }
374 
376  inline const concepts::Karniadakis<1,1>* shpfctDX() const {
377  return shpfctDX_.get(); }
378 
380  virtual const concepts::LaguerreBasis<0>* shpfctY() const = 0;
381 
383  virtual const concepts::LaguerreBasis<1>* shpfctDY() const = 0;
384 
385  virtual const concepts::ElementGraphics<Real>* graphics() const = 0;
386 
388  static Real& borderY() { return borderY_; }
389  protected:
391 
392  void computeIntegrationRule_(const uint nq[2]);
393 
396 
397  virtual std::ostream& info(std::ostream& os) const;
398 
400  ushort p_[2];
401 
403  std::unique_ptr<concepts::QuadratureRule1d> intX_;
404  std::unique_ptr<concepts::QuadratureRule1d> intY_;
405  private:
408 
431  static Real borderY_;
432 
434  std::unique_ptr<concepts::Karniadakis<1,0> > shpfctX_;
436  std::unique_ptr<concepts::Karniadakis<1,1> > shpfctDX_;
437  };
438 
439  // ************************************************** InfiniteLaguerreQuad **
440 
453  public:
464 
466  inline const concepts::LaguerreBasis<0>* shpfctY() const {
467  return shpfctY_.get(); }
468 
470  inline const concepts::LaguerreBasis<1>* shpfctDY() const {
471  return shpfctDY_.get(); }
472 
474 
476  protected:
477  virtual std::ostream& info(std::ostream& os) const;
478  private:
480  static std::unique_ptr<concepts::ElementGraphics<Real> > graphics_;
481 
483  std::unique_ptr<concepts::LaguerreBasis<0> > shpfctY_;
485  std::unique_ptr<concepts::LaguerreBasis<1> > shpfctDY_;
486 
489  };
490 
491  // ****************************************************** ArrayQuadWeights **
492 
495  class ArrayQuadWeights : public concepts::Array<Real> {
496  public:
501  ArrayQuadWeights(const Quad<>& quad);
502  };
503 
504  // ***************************************************** KarniadakisDeriv2 **
505 
518  public:
526  KarniadakisDeriv2(const int P, const Real* xP, const int NxP,
527  const bool cache = true);
528 
530  // commented, because there is not an assignement operator= . See Stroustrup "The Meaning of Copy" and "Explicit Defaults" chapters.
531  //KarniadakisDeriv2(const KarniadakisDeriv2& arg);
532 
534  protected:
535  virtual std::ostream& info(std::ostream& os) const;
536  private:
539  };
540 
541  namespace l2 {
542 
543  // **************************************************** QuadShapeFunctions **
544 
551  public:
564 
567  inline const ushort* p() const { return p_; }
568 
570  inline const KarniadakisDeriv2* shpfctX() const {
571  return shpfctX_.get();
572  }
574  inline const KarniadakisDeriv2* shpfctY() const {
575  return shpfctY_.get(); }
576  protected:
579  private:
581  ushort p_[2];
583  std::unique_ptr<KarniadakisDeriv2 > shpfctX_, shpfctY_;
584  };
585 
586  // ****************************************************************** Quad **
587 
594  template<class F = Real>
595  class Quad : public BaseQuad<F>, public QuadShapeFunctions {
596  public:
607 
608  virtual ~Quad();
609 
610  virtual const concepts::ElementGraphics<F>* graphics() const;
615  void recomputeShapefunctions(const uint nq[2]);
616  protected:
617  virtual std::ostream& info(std::ostream& os) const;
618  private:
620  static std::unique_ptr<concepts::ElementGraphics<F> > graphics_;
621  };
622 
623  } // namespace hp2D::l2
624 
625 } // namespace hp2D
626 
627 #endif // quad_hh
void computeIntegrationRuleFromP_(const ushort *p)
void computeShapefunctions_(const concepts::QuadratureRule2d *intRule)
gets the shapefunctions, used in both constructors
A column of a T matrix.
Definition: analytical.hh:18
virtual Real gramDeterminantRoot(const Real xi, const Real eta) const =0
Returns the square root of the Gram determinant.
Mapping< F, DimX, DimY > inverse() const
Returns the inverse of the matrix.
Handles graphics output (to a file) of a specific element.
Definition: element.hh:16
QuadShapeFunctions(const ushort *p, const concepts::QuadratureRule2d *intRule)
Constructor.
virtual std::ostream & info(std::ostream &os) const
MapReal2d jacobian(const Real xi, const Real eta) const
Computes the Jacobian for xi, eta .
const concepts::LaguerreBasis< 1 > * shpfctDY() const
Returns the derivatives of the shape functions in x direction.
Definition: quad.hh:470
A 2D cell: quadrilateral.
Definition: cell2D.hh:378
ushort p_[2]
Polynomial degree.
Definition: quad.hh:256
void computeIntegrationRule_(const uint nq[2])
static std::unique_ptr< concepts::QuadRuleFactoryTensor2d > & factory()
Access to the quadrature rule, which is valid for all elements of this type (hp2D::IntegrableQuad).
Definition: quad.hh:145
std::unique_ptr< concepts::Karniadakis< 1, 1 > > shpfctDY_
Definition: quad.hh:260
concepts::QuadNd & cell_
The cell.
Definition: quad.hh:162
concepts::Karniadakis< 1, 1 > * tmp_
temporal storage of all derivates of
Definition: quad.hh:538
std::unique_ptr< concepts::Karniadakis< 1, 0 > > shpfctX_
The shape functions.
Definition: quad.hh:434
std::unique_ptr< KarniadakisDeriv2 > shpfctX_
The shape functions.
Definition: quad.hh:583
Integration point consisting of coordinates and intermediate data.
Definition: integral.hh:34
std::unique_ptr< concepts::QuadratureRule1d > intX_
The integration rules.
Definition: quad.hh:403
const concepts::QuadratureRule1d * integrationX() const
Returns the integration rule in x direction.
Definition: quad.hh:339
static void setIntegrationRuleX(enum concepts::intRule rule, bool constant, uint points)
Sets the type of integration rule in x direction to use.
QuadShapeFunctions(const ushort *p, const concepts::QuadratureRule2d *intRule)
Constructor.
A 2D FEM element: an infinite quad with basis based on Laguerre functions.
Definition: quad.hh:452
A 2D FEM element: an infinite quad.
Definition: quad.hh:317
virtual const concepts::LaguerreBasis< 1 > * shpfctDY() const =0
Returns the derivatives of the shape functions in x direction.
A quadrilateral in the topology.
Definition: topology.hh:272
concepts::Real3d vertex(uint i) const
Returns the coordinates of the ith vertex of this element.
Definition: quad.hh:331
static enum concepts::intRule integrationTypeX_
Default behaviour: integration rule Gauss Jacobi (highest order).
Definition: quad.hh:414
virtual concepts::Real3d vertex(uint i) const
Definition: quad.hh:196
intFormType
Integration form, which determines terms coming from integration over reference element.
Definition: integral.hh:29
virtual std::ostream & info(std::ostream &os) const
Returns information in an output stream.
std::unique_ptr< concepts::Karniadakis< 1, 1 > > shpfctDX_
The derivatives of the shape functions.
Definition: quad.hh:260
Quad(concepts::QuadNd &cell, const ushort *p, concepts::TColumn< F > *T0, concepts::TColumn< F > *T1)
Constructor.
std::unique_ptr< concepts::LaguerreBasis< 0 > > shpfctY_
The shape functions in local y-direction.
Definition: quad.hh:483
static Real & borderY()
Largest value in local y coordinates. Default is 1.0.
Definition: quad.hh:388
InfiniteLaguerreQuad(concepts::InfiniteQuad2d &cell, const ushort *p, concepts::TColumn< Real > *T0, concepts::TColumn< Real > *T1)
Constructor.
const ushort * p() const
Returns the polynomial degree.
Definition: quad.hh:230
static uint constNumerOfPointsX_
Number of integration points to use when constant number is requested.
Definition: quad.hh:421
#define conceptsAssert(cond, exc)
Assert that a certain condition is fulfilled.
Definition: exceptions.hh:394
virtual const concepts::ElementGraphics< F > * graphics() const
static enum concepts::intRule integrationTypeY_
Default behaviour: uniform points in [0, border] (Trapezoidal rule).
Definition: quad.hh:417
static std::unique_ptr< concepts::ElementGraphics< Real > > graphics_
Appropiate element graphics object.
Definition: quad.hh:480
void edgeP(const uint i, const uint &p)
Set polynomial degree of edge i to p.
Definition: quad.hh:293
MapReal2d inverseLaplace(const Real xi, const Real eta) const
Computes the second partial derivatives of the inverse Mapping.
static std::unique_ptr< concepts::QuadRuleFactoryTensor2d > factory_
Definition: quad.hh:166
A 2D FEM element: a quad.
Definition: quad.hh:595
const concepts::Karniadakis< 1, 0 > * shpfctX() const
Returns the shape functions in x direction.
Definition: quad.hh:233
concepts::MapReal2d jacobianInverse(const Real x, const Real y) const
Computes the inverse of the Jacobian.
Definition: quad.hh:59
void recomputeShapefunctions()
Recompute shape functions, e.g.
virtual ~BaseQuad()
2D hp-FEM for H1-conforming elements.
concepts::MapReal2d jacobian(const Real x, const Real y) const
Computes the Jacobian.
Definition: quad.hh:45
static std::string integrationRule()
Returns information on the settings of the quadrature rule.
void computeShapefunctionsX_()
gets the shapefunctions in x direction
static bool useConstantNumberOfPointsY_
Definition: quad.hh:429
std::unique_ptr< concepts::Karniadakis< 1, 0 > > shpfctY_
Definition: quad.hh:258
A class for holding the shape functions of nodal elements on quadrilaterials for a particular polynom...
Definition: quad.hh:550
const ushort * p() const
Returns the polynomial degree.
Definition: quad.hh:567
void recomputeShapefunctions(const uint nq[2])
virtual ~InfiniteQuad()
const concepts::QuadratureRule2d *const intRule() const
Definition: quad.hh:136
void setStrategy(const concepts::Quad2dSubdivision *strategy=0)
Sets the subdivision strategy of the underlying cell of this element.
Definition: quad.hh:109
Class holding the quadrature rule and the cell of a quadrilateral element.
Definition: quad.hh:31
ArrayQuadWeights(const Quad<> &quad)
Constructor for a Quad.
virtual ~Quad()
static uint addNumberOfPointsY_
Definition: quad.hh:425
An array of objects.
Definition: bilinearForm.hh:23
Exception class for assertions.
Definition: exceptions.hh:258
Base class for a quadrilateral in any dimension.
Definition: cell2D.hh:187
BaseQuad(concepts::QuadNd &cell, const ushort *p, concepts::TColumn< F > *T0, concepts::TColumn< F > *T1)
Constructor.
const KarniadakisDeriv2 * shpfctY() const
Returns the shape functions in y direction.
Definition: quad.hh:574
InfiniteQuad & connector() const
Returns the quadrilateral connector (topology)
Definition: cell2D.hh:629
const Quad2dSubdivision * getStrategy() const
Returns the subdivision strategy of this quad.
Definition: cell2D.hh:559
virtual std::ostream & info(std::ostream &os) const
Class to represent the quadrature weights on all quadrature points.
Definition: quad.hh:495
A 2D element of the topology.
Definition: connector.hh:226
virtual const concepts::ElementGraphics< F > * graphics() const =0
Returns element graphics class.
Part of the multidimensional expansion bases for the shape functions of Karniadakis and Sherwin.
Definition: quad.hh:517
const concepts::LaguerreBasis< 0 > * shpfctY() const
Returns the shape functions in x direction.
Definition: quad.hh:466
const concepts::Karniadakis< 1, 0 > * shpfctX() const
Returns the shape functions in x direction.
Definition: quad.hh:371
ushort p_[2]
Polynomial degree.
Definition: quad.hh:400
concepts::Real2d chi(const Real x, const Real y) const
Computes the element map, the map from the reference element to the real geometry of the quad.
Definition: quad.hh:40
ushort p_[2]
Polynomial degree.
Definition: quad.hh:581
std::unique_ptr< concepts::LaguerreBasis< 1 > > shpfctDY_
The derivatives of the shape functions in local y-direction.
Definition: quad.hh:485
virtual std::ostream & info(std::ostream &os) const
Abstract class for a 2D FEM element.
Definition: element.hh:28
const ushort * p() const
Returns the polynomial degree.
Definition: quad.hh:336
concepts::MapReal2d inverseLaplace(const Real x, const Real y) const
Definition: quad.hh:66
const concepts::Karniadakis< 1, 1 > * shpfctDX() const
Returns the derivatives of the shape functions in x direction.
Definition: quad.hh:376
void setQuadrature(enum concepts::intRule rule, uint noP)
Tensor integration setter routine in hp2D for hp2D::IntegrableQuads.
intRule
Types of integration rules to choose from.
Definition: defines.hh:13
static Real borderY_
Largest value in local y coordinates. Default is 1.0.
Definition: quad.hh:431
const concepts::QuadratureRule1d * integrationY() const
Returns the integration rule in y direction.
Definition: quad.hh:343
void recomputeShapefunctions(const uint nq[2])
A 2D cell: infinite quadrilateral.
Definition: cell2D.hh:610
std::unique_ptr< concepts::Karniadakis< 1, 0 > > shpfctX_
The shape functions.
Definition: quad.hh:258
Quad(concepts::QuadNd &cell, const ushort *p, concepts::TColumn< F > *T0, concepts::TColumn< F > *T1)
Constructor.
Cell over which can be integrated.
Definition: integral.hh:24
void computeShapefunctions_(const concepts::QuadratureRule2d *intRule)
gets the shapefunctions, used in both constructors
Interface for geometrical subdivision strategies for quadrilaterals.
Definition: cell2D.hh:283
concepts::InfiniteQuad2d & cell_
The cell.
Definition: quad.hh:407
~KarniadakisDeriv2()
Copy constructor.
const concepts::Connector2 & support() const
Definition: quad.hh:330
static uint addNumberOfPointsX_
Number of integration points to add to approximation order when varying number of integration points ...
Definition: quad.hh:425
virtual const concepts::QuadNd & cell() const
Definition: quad.hh:197
const concepts::Quad2dSubdivision * getStrategy() const
Returns the subdivision strategy of the underlying cell of this element.
Definition: quad.hh:122
virtual std::ostream & info(std::ostream &os) const
QuadShapeFunctions(const ushort p, const concepts::QuadratureRule2d *intRule)
Constructor.
static void setIntegrationRuleY(bool constant, uint points, const Real border)
Sets the type of integration rule in y direction to use.
virtual std::ostream & info(std::ostream &os) const
A class for holding the shape functions of nodal elements on quadrilaterials for a particular polynom...
Definition: quad.hh:213
A base of a 2D quad FEM element for different basis functions.
IntegrableQuad(concepts::QuadNd &cell)
std::unique_ptr< concepts::QuadratureRule1d > intY_
Definition: quad.hh:404
virtual const concepts::ElementGraphics< F > * graphics() const
unsigned short ushort
Abbreviation for unsigned short.
Definition: typedefs.hh:48
virtual bool quadraturePoint(uint i, intPoint &p, intFormType form=ZERO, bool localCoord=false) const
Delivers a quadrature point.
virtual ~Quad()
virtual void setStrategy(const Quad2dSubdivision *strategy=0)
Sets the subdivision strategy of this quad.
const uint * edges_[4]
Polynomial degree of edges.
Definition: quad.hh:307
InfiniteQuad(concepts::InfiniteQuad2d &cell, const ushort *p, concepts::TColumn< Real > *T0, concepts::TColumn< Real > *T1)
Constructor.
A 2D FEM element: a quad.
Definition: bf_advection.hh:44
std::unique_ptr< concepts::Karniadakis< 1, 1 > > shpfctDX_
The derivatives of the shape functions.
Definition: quad.hh:436
Polynomial functions which gives a basis of the semi-infinite intervals after multiplication with fac...
Definition: laguerre.hh:67
std::unique_ptr< concepts::QuadratureRule2d > intRule_
The integration rules.
Definition: quad.hh:159
const concepts::Karniadakis< 1, 1 > * shpfctDY() const
Returns the shape functions in y direction.
Definition: quad.hh:244
static bool useConstantNumberOfPointsX_
Use constant number of integration points (true) or not (false).
Definition: quad.hh:429
static concepts::QuadRuleFactoryTensor2d * factory_rp()
Access to the quadrature rule ( as factory() ) through a raw pointer.
Definition: quad.hh:149
virtual const concepts::ElementGraphics< Real > * graphics() const =0
void recomputeShapefunctions()
Recompute shape functions, e.g.
Quadrature rule for numerical integration.
Definition: quadRule.hh:30
const KarniadakisDeriv2 * shpfctX() const
Returns the shape functions in x direction.
Definition: quad.hh:570
const concepts::InfiniteQuad2d & cell() const
Definition: quad.hh:332
const concepts::Karniadakis< 1, 1 > * shpfctDX() const
Returns the derivatives of the shape functions in x direction.
Definition: quad.hh:241
virtual Real3d elemMap(const Real2d &coord_local) const =0
Element map from point local coordinates in 2D.
virtual const concepts::Quad & support() const
Definition: quad.hh:195
static std::unique_ptr< concepts::ElementGraphics< F > > graphics_
Appropiate element graphics object.
Definition: quad.hh:620
virtual const concepts::ElementGraphics< Real > * graphics() const
const uint edgeP(const uint i) const
Definition: quad.hh:296
static void resetIntegrationRule()
Set the standard type of integration.
QuadShapeFunctions(const ushort p, const concepts::QuadratureRule2d *intRule)
Constructor.
static uint constNumerOfPointsY_
Definition: quad.hh:421
Abstract class for quadrature rules in.
Definition: quadRule.hh:347
Abstract class for 1D shape function.
void computeShapefunctionsY_()
gets the shapefunctions in x direction
virtual const concepts::LaguerreBasis< 0 > * shpfctY() const =0
Returns the shape functions in x direction.
This class is the same as QuadRuleFactory, but returning integration rules in 2d.
Definition: quadRule.hh:594
double Real
Type normally used for a floating point number.
Definition: typedefs.hh:36
std::unique_ptr< KarniadakisDeriv2 > shpfctY_
Definition: quad.hh:583
static std::unique_ptr< concepts::ElementGraphics< F > > graphics_
Appropiate element graphics object.
Definition: quad.hh:305
Real3d vertex(uint i) const
Returns the coordinates of the ith vertex.
Basic namespace for Concepts-2.
Definition: pml_formula.h:16
Real gramDeterminantRoot(const Real x, const Real y) const
Computes the sqaure root of the Gram determinant multiplied by 0.25 to incorporate the transformation...
Definition: quad.hh:91
KarniadakisDeriv2(const int P, const Real *xP, const int NxP, const bool cache=true)
Constructor.
const concepts::Karniadakis< 1, 0 > * shpfctY() const
Returns the shape functions in y direction.
Definition: quad.hh:237
Part of the multidimensional expansion bases for the shape functions of Karniadakis and Sherwin.
Definition: karniadakis.hh:163
Page URL: http://wiki.math.ethz.ch/bin/view/Concepts/WebHome
21 August 2020
© 2020 Eidgenössische Technische Hochschule Zürich