void QGrid::init_2D(const ElemType type_in, unsigned int) { #if LIBMESH_DIM > 1 //----------------------------------------------------------------------- // 2D quadrature rules // We ignore p - the grid rule is just for experimentation switch (type_in) { //--------------------------------------------- // Quadrilateral quadrature rules case QUAD4: case QUAD8: case QUAD9: { // We compute the 2D quadrature rule as a tensor // product of the 1D quadrature rule. QGrid q1D(1,_order); q1D.init(EDGE2); tensor_product_quad( q1D ); return; } //--------------------------------------------- // Triangle quadrature rules case TRI3: case TRI6: { const unsigned int np = (_order + 1)*(_order + 2)/2; const Real weight = 0.5/np; const Real dx = 1.0/(_order+1); _points.resize(np); _weights.resize(np); unsigned int pt = 0; for (int i = 0; i != _order + 1; ++i) { for (int j = 0; j != _order + 1 - i; ++j) { _points[pt](0) = (i+0.5)*dx; _points[pt](1) = (j+0.5)*dx; _weights[pt] = weight; pt++; } } return; } //--------------------------------------------- // Unsupported type default: { libMesh::err << "Element type not supported!:" << type_in << std::endl; libmesh_error(); } } libmesh_error(); return; #endif }
void QSimpson::init_2D(const ElemType type_in, unsigned int) { #if LIBMESH_DIM > 1 //----------------------------------------------------------------------- // 2D quadrature rules switch (type_in) { //--------------------------------------------- // Quadrilateral quadrature rules case QUAD4: case QUAD8: case QUAD9: { // We compute the 2D quadrature rule as a tensor // product of the 1D quadrature rule. QSimpson q1D(1); q1D.init(EDGE2); tensor_product_quad( q1D ); return; } //--------------------------------------------- // Triangle quadrature rules case TRI3: case TRI6: { // I'm not sure if you would call this Simpson's // rule for triangles. What it *Really* is is // four trapezoidal rules combined to give a six // point rule. The points lie at the nodal locations // of the TRI6, so you can get diagonal element // stiffness matrix entries for quadratic elements. // This rule should be able to integrate a little // better than linears exactly. _points.resize(6); _weights.resize(6); _points[0](0) = 0.; _points[0](1) = 0.; _points[1](0) = 1.; _points[1](1) = 0.; _points[2](0) = 0.; _points[2](1) = 1.; _points[3](0) = 0.5; _points[3](1) = 0.; _points[4](0) = 0.; _points[4](1) = 0.5; _points[5](0) = 0.5; _points[5](1) = 0.5; _weights[0] = 0.041666666666666666666666666667; // 1./24. _weights[1] = 0.041666666666666666666666666667; // 1./24. _weights[2] = 0.041666666666666666666666666667; // 1./24. _weights[3] = 0.125; // 1./8. _weights[4] = 0.125; // 1./8. _weights[5] = 0.125; // 1./8. return; } //--------------------------------------------- // Unsupported type default: { libMesh::err << "Element type not supported!:" << type_in << std::endl; libmesh_error(); } } libmesh_error(); return; #endif }
void QTrap::init_2D(const ElemType type_in, unsigned int) { #if LIBMESH_DIM > 1 //----------------------------------------------------------------------- // 2D quadrature rules switch (type_in) { //--------------------------------------------- // Quadrilateral quadrature rules case QUAD4: case QUAD8: case QUAD9: { // We compute the 2D quadrature rule as a tensor // product of the 1D quadrature rule. QTrap q1D(1); q1D.init(EDGE2); tensor_product_quad( q1D ); return; } //--------------------------------------------- // Triangle quadrature rules case TRI3: case TRI6: { _points.resize(3); _weights.resize(3); _points[0](0) = 0.; _points[0](1) = 0.; _points[1](0) = 1.; _points[1](1) = 0.; _points[2](0) = 0.; _points[2](1) = 1.; _weights[0] = 1./6.; _weights[1] = 1./6.; _weights[2] = 1./6.; return; } //--------------------------------------------- // Unsupported type default: { libMesh::err << "Element type not supported!:" << type_in << std::endl; libmesh_error(); } } libmesh_error(); return; #endif }