void QGaussLobatto::init_3D(const ElemType type_in, unsigned int p) { switch (type_in) { case HEX8: case HEX20: case HEX27: { // We compute the 3D quadrature rule as a tensor // product of the 1D quadrature rule. QGaussLobatto q1D(1, _order); q1D.init(EDGE2, p); tensor_product_hex(q1D); return; } // We *could* fall back to a Gauss type rule for other types // elements, but the assumption here is that the user has asked // for a Gauss-Lobatto rule, i.e. a rule with integration points // on the element boundary, for a reason. default: libmesh_error_msg("ERROR: Unsupported type: " << type_in); } }
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 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_3D(const ElemType type_in, unsigned int) { #if LIBMESH_DIM == 3 //----------------------------------------------------------------------- // 3D quadrature rules switch (type_in) { //--------------------------------------------- // Hex quadrature rules case HEX8: case HEX20: case HEX27: { // We compute the 3D quadrature rule as a tensor // product of the 1D quadrature rule. QSimpson q1D(1); q1D.init(EDGE2); tensor_product_hex( q1D ); return; } //--------------------------------------------- // Tetrahedral quadrature rules case TET4: case TET10: { // This rule is created by combining 8 subtets // which use the trapezoidal rule. The weights // may seem a bit odd, but they are correct, // and should add up to 1/6, the volume of the // reference tet. The points of this rule are // at the nodal points of the TET10, allowing // you to generate diagonal element stiffness // matrices when using quadratic elements. // It should be able to integrate something // better than linears, but I'm not sure how // high. _points.resize(10); _weights.resize(10); _points[0](0) = 0.; _points[5](0) = .5; _points[0](1) = 0.; _points[5](1) = .5; _points[0](2) = 0.; _points[5](2) = 0.; _points[1](0) = 1.; _points[6](0) = 0.; _points[1](1) = 0.; _points[6](1) = .5; _points[1](2) = 0.; _points[6](2) = 0.; _points[2](0) = 0.; _points[7](0) = 0.; _points[2](1) = 1.; _points[7](1) = 0.; _points[2](2) = 0.; _points[7](2) = .5; _points[3](0) = 0.; _points[8](0) = .5; _points[3](1) = 0.; _points[8](1) = 0.; _points[3](2) = 1.; _points[8](2) = .5; _points[4](0) = .5; _points[9](0) = 0.; _points[4](1) = 0.; _points[9](1) = .5; _points[4](2) = 0.; _points[9](2) = .5; _weights[0] = Real(1)/192; _weights[1] = _weights[0]; _weights[2] = _weights[0]; _weights[3] = _weights[0]; _weights[4] = Real(14)/576; _weights[5] = _weights[4]; _weights[6] = _weights[4]; _weights[7] = _weights[4]; _weights[8] = _weights[4]; _weights[9] = _weights[4]; return; } //--------------------------------------------- // Prism quadrature rules case PRISM6: case PRISM15: case PRISM18: { // We compute the 3D quadrature rule as a tensor // product of the 1D quadrature rule and a 2D // triangle quadrature rule QSimpson q1D(1); QSimpson q2D(2); // Initialize q1D.init(EDGE2); q2D.init(TRI3); tensor_product_prism(q1D, q2D); return; } //--------------------------------------------- // Unsupported type default: libmesh_error_msg("ERROR: Unsupported type: " << type_in); } #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 }
void QTrap::init_3D(const ElemType type_in, unsigned int) { #if LIBMESH_DIM == 3 //----------------------------------------------------------------------- // 3D quadrature rules switch (type_in) { //--------------------------------------------- // Hex quadrature rules case HEX8: case HEX20: case HEX27: { // We compute the 3D quadrature rule as a tensor // product of the 1D quadrature rule. QTrap q1D(1); q1D.init(EDGE2); tensor_product_hex( q1D ); return; } //--------------------------------------------- // Tetrahedral quadrature rules case TET4: case TET10: { _points.resize(4); _weights.resize(4); _points[0](0) = 0.; _points[0](1) = 0.; _points[0](2) = 0.; _points[1](0) = 1.; _points[1](1) = 0.; _points[1](2) = 0.; _points[2](0) = 0.; _points[2](1) = 1.; _points[2](2) = 0.; _points[3](0) = 0.; _points[3](1) = 0.; _points[3](2) = 1.; _weights[0] = .0416666666666666666666666666666666666666666667; _weights[1] = _weights[0]; _weights[2] = _weights[0]; _weights[3] = _weights[0]; return; } //--------------------------------------------- // Prism quadrature rules case PRISM6: case PRISM15: case PRISM18: { // We compute the 3D quadrature rule as a tensor // product of the 1D quadrature rule and a 2D // triangle quadrature rule QTrap q1D(1); QTrap q2D(2); // Initialize q1D.init(EDGE2); q2D.init(TRI3); tensor_product_prism(q1D, q2D); return; } //--------------------------------------------- // Unsupported type default: { libMesh::err << "ERROR: Unsupported type: " << type_in << std::endl; libmesh_error(); } } libmesh_error(); return; #endif }