void QMonomial::init_1D(const ElemType _elemtype, unsigned int p) { QGauss gauss_rule(1, _order); gauss_rule.init(_elemtype, p); _points.swap(gauss_rule.get_points()); _weights.swap(gauss_rule.get_weights()); }
void QClough::init_2D(const ElemType type_in, unsigned int p) { #if LIBMESH_DIM > 1 QGauss gauss_rule(2, _order); gauss_rule.init(TRI6, p); //----------------------------------------------------------------------- // 2D quadrature rules switch (type_in) { //--------------------------------------------- // Triangle quadrature rules case TRI3: case TRI6: { std::vector<Point> & gausspoints = gauss_rule.get_points(); std::vector<Real> & gaussweights = gauss_rule.get_weights(); std::size_t numgausspts = gausspoints.size(); _points.resize(numgausspts*3); _weights.resize(numgausspts*3); for (std::size_t i = 0; i != numgausspts; ++i) { _points[3*i](0) = gausspoints[i](0) + gausspoints[i](1) / 3.; _points[3*i](1) = gausspoints[i](1) / 3.; _points[3*i+1](0) = gausspoints[i](1) / 3.; _points[3*i+1](1) = gausspoints[i](0) + gausspoints[i](1) / 3.; _points[3*i+2](0) = 1./3. + gausspoints[i](0) * 2./3. - gausspoints[i](1) / 3.; _points[3*i+2](1) = 1./3. - gausspoints[i](0) / 3. + gausspoints[i](1) * 2./3.; _weights[3*i] = gaussweights[i] / 3.; _weights[3*i+1] = _weights[3*i]; _weights[3*i+2] = _weights[3*i]; } return; } //--------------------------------------------- // Unsupported type default: libmesh_error_msg("Element type not supported!:" << type_in); } #endif }
void QMonomial::init_2D(const ElemType _type, unsigned int p) { switch (_type) { //--------------------------------------------- // Quadrilateral quadrature rules case QUAD4: case QUAD8: case QUAD9: { switch(_order + 2*p) { case SECOND: { // A degree=2 rule for the QUAD with 3 points. // A tensor product degree-2 Gauss would have 4 points. // This rule (or a variation on it) is probably available in // // A.H. Stroud, Approximate calculation of multiple integrals, // Prentice-Hall, Englewood Cliffs, N.J., 1971. // // though I have never actually seen a reference for it. // Luckily it's fairly easy to derive, which is what I've done // here [JWP]. const Real s=std::sqrt(1./3.), t=std::sqrt(2./3.); const Real data[2][3] = { {0.0, s, 2.0}, { t, -s, 1.0} }; _points.resize(3); _weights.resize(3); wissmann_rule(data, 2); return; } // end case SECOND // For third-order, fall through to default case, use 2x2 Gauss product rule. // case THIRD: // { // } // end case THIRD case FOURTH: { // A pair of degree=4 rules for the QUAD "C2" due to // Wissmann and Becker. These rules both have six points. // A tensor product degree-4 Gauss would have 9 points. // // J. W. Wissmann and T. Becker, Partially symmetric cubature // formulas for even degrees of exactness, SIAM J. Numer. Anal. 23 // (1986), 676--685. const Real data[4][3] = { // First of 2 degree-4 rules given by Wissmann {0.0000000000000000e+00, 0.0000000000000000e+00, 1.1428571428571428e+00}, {0.0000000000000000e+00, 9.6609178307929590e-01, 4.3956043956043956e-01}, {8.5191465330460049e-01, 4.5560372783619284e-01, 5.6607220700753210e-01}, {6.3091278897675402e-01, -7.3162995157313452e-01, 6.4271900178367668e-01} // // Second of 2 degree-4 rules given by Wissmann. These both // yield 4th-order accurate rules, I just chose the one that // happened to contain the origin. // {0.000000000000000, -0.356822089773090, 1.286412084888852}, // {0.000000000000000, 0.934172358962716, 0.491365692888926}, // {0.774596669241483, 0.390885162530071, 0.761883709085613}, // {0.774596669241483, -0.852765377881771, 0.349227402025498} }; _points.resize(6); _weights.resize(6); wissmann_rule(data, 4); return; } // end case FOURTH case FIFTH: { // A degree 5, 7-point rule due to Stroud. // // A.H. Stroud, Approximate calculation of multiple integrals, // Prentice-Hall, Englewood Cliffs, N.J., 1971. // // This rule is provably minimal in the number of points. // A tensor-product rule accurate for "bi-quintic" polynomials would have 9 points. const Real data[3][3] = { { 0.L, 0.L, 8.L / 7.L}, // 1 { 0.L, static_cast<Real>(std::sqrt(14.L/15.L)), 20.L / 63.L}, // 2 {static_cast<Real>(std::sqrt(3.L/5.L)), static_cast<Real>(std::sqrt(1.L/3.L)), 20.L / 36.L} // 4 }; const unsigned int symmetry[3] = { 0, // Origin 7, // Central Symmetry 6 // Rectangular }; _points.resize (7); _weights.resize(7); stroud_rule(data, symmetry, 3); return; } // end case FIFTH case SIXTH: { // A pair of degree=6 rules for the QUAD "C2" due to // Wissmann and Becker. These rules both have 10 points. // A tensor product degree-6 Gauss would have 16 points. // // J. W. Wissmann and T. Becker, Partially symmetric cubature // formulas for even degrees of exactness, SIAM J. Numer. Anal. 23 // (1986), 676--685. const Real data[6][3] = { // First of 2 degree-6, 10 point rules given by Wissmann // {0.000000000000000, 0.836405633697626, 0.455343245714174}, // {0.000000000000000, -0.357460165391307, 0.827395973202966}, // {0.888764014654765, 0.872101531193131, 0.144000884599645}, // {0.604857639464685, 0.305985162155427, 0.668259104262665}, // {0.955447506641064, -0.410270899466658, 0.225474004890679}, // {0.565459993438754, -0.872869311156879, 0.320896396788441} // // Second of 2 degree-6, 10 point rules given by Wissmann. // Either of these will work, I just chose the one with points // slightly further into the element interior. {0.0000000000000000e+00, 8.6983337525005900e-01, 3.9275059096434794e-01}, {0.0000000000000000e+00, -4.7940635161211124e-01, 7.5476288124261053e-01}, {8.6374282634615388e-01, 8.0283751620765670e-01, 2.0616605058827902e-01}, {5.1869052139258234e-01, 2.6214366550805818e-01, 6.8999213848986375e-01}, {9.3397254497284950e-01, -3.6309658314806653e-01, 2.6051748873231697e-01}, {6.0897753601635630e-01, -8.9660863276245265e-01, 2.6956758608606100e-01} }; _points.resize(10); _weights.resize(10); wissmann_rule(data, 6); return; } // end case SIXTH case SEVENTH: { // A degree 7, 12-point rule due to Tyler, can be found in Stroud's book // // A.H. Stroud, Approximate calculation of multiple integrals, // Prentice-Hall, Englewood Cliffs, N.J., 1971. // // This rule is fully-symmetric and provably minimal in the number of points. // A tensor-product rule accurate for "bi-septic" polynomials would have 16 points. const Real r = std::sqrt(6.L/7.L), s = std::sqrt( (114.L - 3.L*std::sqrt(583.L)) / 287.L ), t = std::sqrt( (114.L + 3.L*std::sqrt(583.L)) / 287.L ), B1 = 196.L / 810.L, B2 = 4.L * (178981.L + 2769.L*std::sqrt(583.L)) / 1888920.L, B3 = 4.L * (178981.L - 2769.L*std::sqrt(583.L)) / 1888920.L; const Real data[3][3] = { {r, 0.0, B1}, // 4 {s, 0.0, B2}, // 4 {t, 0.0, B3} // 4 }; const unsigned int symmetry[3] = { 3, // Full Symmetry, (x,0) 2, // Full Symmetry, (x,x) 2 // Full Symmetry, (x,x) }; _points.resize (12); _weights.resize(12); stroud_rule(data, symmetry, 3); return; } // end case SEVENTH case EIGHTH: { // A pair of degree=8 rules for the QUAD "C2" due to // Wissmann and Becker. These rules both have 16 points. // A tensor product degree-6 Gauss would have 25 points. // // J. W. Wissmann and T. Becker, Partially symmetric cubature // formulas for even degrees of exactness, SIAM J. Numer. Anal. 23 // (1986), 676--685. const Real data[10][3] = { // First of 2 degree-8, 16 point rules given by Wissmann // {0.000000000000000, 0.000000000000000, 0.055364705621440}, // {0.000000000000000, 0.757629177660505, 0.404389368726076}, // {0.000000000000000, -0.236871842255702, 0.533546604952635}, // {0.000000000000000, -0.989717929044527, 0.117054188786739}, // {0.639091304900370, 0.950520955645667, 0.125614417613747}, // {0.937069076924990, 0.663882736885633, 0.136544584733588}, // {0.537083530541494, 0.304210681724104, 0.483408479211257}, // {0.887188506449625, -0.236496718536120, 0.252528506429544}, // {0.494698820670197, -0.698953476086564, 0.361262323882172}, // {0.897495818279768, -0.900390774211580, 0.085464254086247} // // Second of 2 degree-8, 16 point rules given by Wissmann. // Either of these will work, I just chose the one with points // further into the element interior. {0.0000000000000000e+00, 6.5956013196034176e-01, 4.5027677630559029e-01}, {0.0000000000000000e+00, -9.4914292304312538e-01, 1.6657042677781274e-01}, {9.5250946607156228e-01, 7.6505181955768362e-01, 9.8869459933431422e-02}, {5.3232745407420624e-01, 9.3697598108841598e-01, 1.5369674714081197e-01}, {6.8473629795173504e-01, 3.3365671773574759e-01, 3.9668697607290278e-01}, {2.3314324080140552e-01, -7.9583272377396852e-02, 3.5201436794569501e-01}, {9.2768331930611748e-01, -2.7224008061253425e-01, 1.8958905457779799e-01}, {4.5312068740374942e-01, -6.1373535339802760e-01, 3.7510100114758727e-01}, {8.3750364042281223e-01, -8.8847765053597136e-01, 1.2561879164007201e-01} }; _points.resize(16); _weights.resize(16); wissmann_rule(data, /*10*/ 9); return; } // end case EIGHTH case NINTH: { // A degree 9, 17-point rule due to Moller. // // H.M. Moller, Kubaturformeln mit minimaler Knotenzahl, // Numer. Math. 25 (1976), 185--200. // // This rule is provably minimal in the number of points. // A tensor-product rule accurate for "bi-ninth" degree polynomials would have 25 points. const Real data[5][3] = { {0.0000000000000000e+00, 0.0000000000000000e+00, 5.2674897119341563e-01}, // 1 {6.3068011973166885e-01, 9.6884996636197772e-01, 8.8879378170198706e-02}, // 4 {9.2796164595956966e-01, 7.5027709997890053e-01, 1.1209960212959648e-01}, // 4 {4.5333982113564719e-01, 5.2373582021442933e-01, 3.9828243926207009e-01}, // 4 {8.5261572933366230e-01, 7.6208328192617173e-02, 2.6905133763978080e-01} // 4 }; const unsigned int symmetry[5] = { 0, // Single point 4, // Rotational Invariant 4, // Rotational Invariant 4, // Rotational Invariant 4 // Rotational Invariant }; _points.resize (17); _weights.resize(17); stroud_rule(data, symmetry, 5); return; } // end case NINTH case TENTH: case ELEVENTH: { // A degree 11, 24-point rule due to Cools and Haegemans. // // R. Cools and A. Haegemans, Another step forward in searching for // cubature formulae with a minimal number of knots for the square, // Computing 40 (1988), 139--146. // // P. Verlinden and R. Cools, The algebraic construction of a minimal // cubature formula of degree 11 for the square, Cubature Formulas // and their Applications (Russian) (Krasnoyarsk) (M.V. Noskov, ed.), // 1994, pp. 13--23. // // This rule is provably minimal in the number of points. // A tensor-product rule accurate for "bi-tenth" or "bi-eleventh" degree polynomials would have 36 points. const Real data[6][3] = { {6.9807610454956756e-01, 9.8263922354085547e-01, 4.8020763350723814e-02}, // 4 {9.3948638281673690e-01, 8.2577583590296393e-01, 6.6071329164550595e-02}, // 4 {9.5353952820153201e-01, 1.8858613871864195e-01, 9.7386777358668164e-02}, // 4 {3.1562343291525419e-01, 8.1252054830481310e-01, 2.1173634999894860e-01}, // 4 {7.1200191307533630e-01, 5.2532025036454776e-01, 2.2562606172886338e-01}, // 4 {4.2484724884866925e-01, 4.1658071912022368e-02, 3.5115871839824543e-01} // 4 }; const unsigned int symmetry[6] = { 4, // Rotational Invariant 4, // Rotational Invariant 4, // Rotational Invariant 4, // Rotational Invariant 4, // Rotational Invariant 4 // Rotational Invariant }; _points.resize (24); _weights.resize(24); stroud_rule(data, symmetry, 6); return; } // end case TENTH,ELEVENTH case TWELFTH: case THIRTEENTH: { // A degree 13, 33-point rule due to Cools and Haegemans. // // R. Cools and A. Haegemans, Another step forward in searching for // cubature formulae with a minimal number of knots for the square, // Computing 40 (1988), 139--146. // // A tensor-product rule accurate for "bi-12" or "bi-13" degree polynomials would have 49 points. const Real data[9][3] = { {0.0000000000000000e+00, 0.0000000000000000e+00, 3.0038211543122536e-01}, // 1 {9.8348668243987226e-01, 7.7880971155441942e-01, 2.9991838864499131e-02}, // 4 {8.5955600564163892e-01, 9.5729769978630736e-01, 3.8174421317083669e-02}, // 4 {9.5892517028753485e-01, 1.3818345986246535e-01, 6.0424923817749980e-02}, // 4 {3.9073621612946100e-01, 9.4132722587292523e-01, 7.7492738533105339e-02}, // 4 {8.5007667369974857e-01, 4.7580862521827590e-01, 1.1884466730059560e-01}, // 4 {6.4782163718701073e-01, 7.5580535657208143e-01, 1.2976355037000271e-01}, // 4 {7.0741508996444936e-02, 6.9625007849174941e-01, 2.1334158145718938e-01}, // 4 {4.0930456169403884e-01, 3.4271655604040678e-01, 2.5687074948196783e-01} // 4 }; const unsigned int symmetry[9] = { 0, // Single point 4, // Rotational Invariant 4, // Rotational Invariant 4, // Rotational Invariant 4, // Rotational Invariant 4, // Rotational Invariant 4, // Rotational Invariant 4, // Rotational Invariant 4 // Rotational Invariant }; _points.resize (33); _weights.resize(33); stroud_rule(data, symmetry, 9); return; } // end case TWELFTH,THIRTEENTH case FOURTEENTH: case FIFTEENTH: { // A degree-15, 48 point rule originally due to Rabinowitz and Richter, // can be found in Cools' 1971 book. // // A.H. Stroud, Approximate calculation of multiple integrals, // Prentice-Hall, Englewood Cliffs, N.J., 1971. // // The product Gauss rule for this order has 8^2=64 points. const Real data[9][3] = { {9.915377816777667e-01L, 0.0000000000000000e+00, 3.01245207981210e-02L}, // 4 {8.020163879230440e-01L, 0.0000000000000000e+00, 8.71146840209092e-02L}, // 4 {5.648674875232742e-01L, 0.0000000000000000e+00, 1.250080294351494e-01L}, // 4 {9.354392392539896e-01L, 0.0000000000000000e+00, 2.67651407861666e-02L}, // 4 {7.624563338825799e-01L, 0.0000000000000000e+00, 9.59651863624437e-02L}, // 4 {2.156164241427213e-01L, 0.0000000000000000e+00, 1.750832998343375e-01L}, // 4 {9.769662659711761e-01L, 6.684480048977932e-01L, 2.83136372033274e-02L}, // 4 {8.937128379503403e-01L, 3.735205277617582e-01L, 8.66414716025093e-02L}, // 4 {6.122485619312083e-01L, 4.078983303613935e-01L, 1.150144605755996e-01L} // 4 }; const unsigned int symmetry[9] = { 3, // Full Symmetry, (x,0) 3, // Full Symmetry, (x,0) 3, // Full Symmetry, (x,0) 2, // Full Symmetry, (x,x) 2, // Full Symmetry, (x,x) 2, // Full Symmetry, (x,x) 1, // Full Symmetry, (x,y) 1, // Full Symmetry, (x,y) 1, // Full Symmetry, (x,y) }; _points.resize (48); _weights.resize(48); stroud_rule(data, symmetry, 9); return; } // case FOURTEENTH, FIFTEENTH: case SIXTEENTH: case SEVENTEENTH: { // A degree 17, 60-point rule due to Cools and Haegemans. // // R. Cools and A. Haegemans, Another step forward in searching for // cubature formulae with a minimal number of knots for the square, // Computing 40 (1988), 139--146. // // A tensor-product rule accurate for "bi-14" or "bi-15" degree polynomials would have 64 points. // A tensor-product rule accurate for "bi-16" or "bi-17" degree polynomials would have 81 points. const Real data[10][3] = { {9.8935307451260049e-01, 0.0000000000000000e+00, 2.0614915919990959e-02}, // 4 {3.7628520715797329e-01, 0.0000000000000000e+00, 1.2802571617990983e-01}, // 4 {9.7884827926223311e-01, 0.0000000000000000e+00, 5.5117395340318905e-03}, // 4 {8.8579472916411612e-01, 0.0000000000000000e+00, 3.9207712457141880e-02}, // 4 {1.7175612383834817e-01, 0.0000000000000000e+00, 7.6396945079863302e-02}, // 4 {5.9049927380600241e-01, 3.1950503663457394e-01, 1.4151372994997245e-01}, // 8 {7.9907913191686325e-01, 5.9797245192945738e-01, 8.3903279363797602e-02}, // 8 {8.0374396295874471e-01, 5.8344481776550529e-02, 6.0394163649684546e-02}, // 8 {9.3650627612749478e-01, 3.4738631616620267e-01, 5.7387752969212695e-02}, // 8 {9.8132117980545229e-01, 7.0600028779864611e-01, 2.1922559481863763e-02}, // 8 }; const unsigned int symmetry[10] = { 3, // Fully symmetric (x,0) 3, // Fully symmetric (x,0) 2, // Fully symmetric (x,x) 2, // Fully symmetric (x,x) 2, // Fully symmetric (x,x) 1, // Fully symmetric (x,y) 1, // Fully symmetric (x,y) 1, // Fully symmetric (x,y) 1, // Fully symmetric (x,y) 1 // Fully symmetric (x,y) }; _points.resize (60); _weights.resize(60); stroud_rule(data, symmetry, 10); return; } // end case FOURTEENTH through SEVENTEENTH // By default: construct and use a Gauss quadrature rule default: { // Break out and fall down into the default: case for the // outer switch statement. break; } } // end switch(_order + 2*p) } // end case QUAD4/8/9 // By default: construct and use a Gauss quadrature rule default: { QGauss gauss_rule(2, _order); gauss_rule.init(_type, p); // Swap points and weights with the about-to-be destroyed rule. _points.swap (gauss_rule.get_points() ); _weights.swap(gauss_rule.get_weights()); return; } } // end switch (_type) }
void QMonomial::init_3D(const ElemType type_in, unsigned int p) { switch (type_in) { //--------------------------------------------- // Hex quadrature rules case HEX8: case HEX20: case HEX27: { switch(_order + 2*p) { // The CONSTANT/FIRST rule is the 1-point Gauss "product" rule...we fall // through to the default case for this rule. case SECOND: case THIRD: { // A degree 3, 6-point, "rotationally-symmetric" rule by // Kim and Song, Comm. Korean Math. Soc vol. 13, no. 4, 1998, pp. 913-931. // // Warning: this rule contains points on the boundary of the reference // element, and therefore may be unsuitable for some problems. The alternative // would be a 2x2x2 Gauss product rule. const Real data[1][4] = { {1.0L, 0.0L, 0.0L, Real(4)/3} }; const unsigned int rule_id[1] = { 1 // (x,0,0) -> 6 permutations }; _points.resize(6); _weights.resize(6); kim_rule(data, rule_id, 1); return; } // end case SECOND,THIRD case FOURTH: case FIFTH: { // A degree 5, 13-point rule by Stroud, // AH Stroud, "Some Fifth Degree Integration Formulas for Symmetric Regions II.", // Numerische Mathematik 9, pp. 460-468 (1967). // // This rule is provably minimal in the number of points. The equations given for // the n-cube on pg. 466 of the paper for mu/gamma and gamma are wrong, at least for // the n=3 case. The analytical values given here were computed by me [JWP] in Maple. // Convenient intermediate values. const Real sqrt19 = std::sqrt(19.L); const Real tp = std::sqrt(71440 + 6802*sqrt19); // Point data for permutations. const Real eta = 0.00000000000000000000000000000000e+00L; const Real lambda = std::sqrt(1919.L/3285.L - 148.L*sqrt19/3285.L + 4.L*tp/3285.L); // 8.8030440669930978047737818209860e-01L; const Real xi = -std::sqrt(1121.L/3285.L + 74.L*sqrt19/3285.L - 2.L*tp/3285.L); // -4.9584817142571115281421242364290e-01L; const Real mu = std::sqrt(1121.L/3285.L + 74.L*sqrt19/3285.L + 2.L*tp/3285.L); // 7.9562142216409541542982482567580e-01L; const Real gamma = std::sqrt(1919.L/3285.L - 148.L*sqrt19/3285.L - 4.L*tp/3285.L); // 2.5293711744842581347389255929324e-02L; // Weights: the centroid weight is given analytically. Weight B (resp C) goes // with the {lambda,xi} (resp {gamma,mu}) permutation. The single-precision // results reported by Stroud are given for reference. const Real A = Real(32)/19; // Stroud: 0.21052632 * 8.0 = 1.684210560; const Real B = Real(1) / (Real(260072)/133225 - 1520*sqrt19/133225 + (133 - 37*sqrt19)*tp/133225); // 5.4498735127757671684690782180890e-01L; // Stroud: 0.068123420 * 8.0 = 0.544987360; const Real C = Real(1) / (Real(260072)/133225 - 1520*sqrt19/133225 - (133 - 37*sqrt19)*tp/133225); // 5.0764422766979170420572375713840e-01L; // Stroud: 0.063455527 * 8.0 = 0.507644216; _points.resize(13); _weights.resize(13); unsigned int c=0; // Point with weight A (origin) _points[c] = Point(eta, eta, eta); _weights[c++] = A; // Points with weight B _points[c] = Point(lambda, xi, xi); _weights[c++] = B; _points[c] = -_points[c-1]; _weights[c++] = B; _points[c] = Point(xi, lambda, xi); _weights[c++] = B; _points[c] = -_points[c-1]; _weights[c++] = B; _points[c] = Point(xi, xi, lambda); _weights[c++] = B; _points[c] = -_points[c-1]; _weights[c++] = B; // Points with weight C _points[c] = Point(mu, mu, gamma); _weights[c++] = C; _points[c] = -_points[c-1]; _weights[c++] = C; _points[c] = Point(mu, gamma, mu); _weights[c++] = C; _points[c] = -_points[c-1]; _weights[c++] = C; _points[c] = Point(gamma, mu, mu); _weights[c++] = C; _points[c] = -_points[c-1]; _weights[c++] = C; return; // // A degree 5, 14-point, "rotationally-symmetric" rule by // // Kim and Song, Comm. Korean Math. Soc vol. 13, no. 4, 1998, pp. 913-931. // // Was also reported in Stroud's 1971 book. // const Real data[2][4] = // { // {7.95822425754221463264548820476135e-01L, 0.00000000000000000000000000000000e+00L, 0.00000000000000000000000000000000e+00L, 8.86426592797783933518005540166204e-01L}, // {7.58786910639328146269034278112267e-01L, 7.58786910639328146269034278112267e-01L, 7.58786910639328146269034278112267e-01L, 3.35180055401662049861495844875346e-01L} // }; // const unsigned int rule_id[2] = { // 1, // (x,0,0) -> 6 permutations // 4 // (x,x,x) -> 8 permutations // }; // _points.resize(14); // _weights.resize(14); // kim_rule(data, rule_id, 2); // return; } // end case FOURTH,FIFTH case SIXTH: case SEVENTH: { if (allow_rules_with_negative_weights) { // A degree 7, 31-point, "rotationally-symmetric" rule by // Kim and Song, Comm. Korean Math. Soc vol. 13, no. 4, 1998, pp. 913-931. // This rule contains a negative weight, so only use it if such type of // rules are allowed. const Real data[3][4] = { {0.00000000000000000000000000000000e+00L, 0.00000000000000000000000000000000e+00L, 0.00000000000000000000000000000000e+00L, -1.27536231884057971014492753623188e+00L}, {5.85540043769119907612630781744060e-01L, 0.00000000000000000000000000000000e+00L, 0.00000000000000000000000000000000e+00L, 8.71111111111111111111111111111111e-01L}, {6.94470135991704766602025803883310e-01L, 9.37161638568208038511047377665396e-01L, 4.15659267604065126239606672567031e-01L, 1.68695652173913043478260869565217e-01L} }; const unsigned int rule_id[3] = { 0, // (0,0,0) -> 1 permutation 1, // (x,0,0) -> 6 permutations 6 // (x,y,z) -> 24 permutations }; _points.resize(31); _weights.resize(31); kim_rule(data, rule_id, 3); return; } // end if (allow_rules_with_negative_weights) // A degree 7, 34-point, "fully-symmetric" rule, first published in // P.C. Hammer and A.H. Stroud, "Numerical Evaluation of Multiple Integrals II", // Mathmatical Tables and Other Aids to Computation, vol 12., no 64, 1958, pp. 272-280 // // This rule happens to fall under the same general // construction as the Kim rules, so we've re-used // that code here. Stroud gives 16 digits for his rule, // and this is the most accurate version I've found. // // For comparison, a SEVENTH-order Gauss product rule // (which integrates tri-7th order polynomials) would // have 4^3=64 points. const Real r = std::sqrt(6.L/7.L), s = std::sqrt((960.L - 3.L*std::sqrt(28798.L)) / 2726.L), t = std::sqrt((960.L + 3.L*std::sqrt(28798.L)) / 2726.L), B1 = Real(8624)/29160, B2 = Real(2744)/29160, B3 = 8*(774*t*t - 230)/(9720*(t*t-s*s)), B4 = 8*(230 - 774*s*s)/(9720*(t*t-s*s)); const Real data[4][4] = { {r, 0, 0, B1}, {r, r, 0, B2}, {s, s, s, B3}, {t, t, t, B4} }; const unsigned int rule_id[4] = { 1, // (x,0,0) -> 6 permutations 2, // (x,x,0) -> 12 permutations 4, // (x,x,x) -> 8 permutations 4 // (x,x,x) -> 8 permutations }; _points.resize(34); _weights.resize(34); kim_rule(data, rule_id, 4); return; // // A degree 7, 38-point, "rotationally-symmetric" rule by // // Kim and Song, Comm. Korean Math. Soc vol. 13, no. 4, 1998, pp. 913-931. // // // // This rule is obviously inferior to the 34-point rule above... // const Real data[3][4] = //{ // {9.01687807821291289082811566285950e-01L, 0.00000000000000000000000000000000e+00L, 0.00000000000000000000000000000000e+00L, 2.95189738262622903181631100062774e-01L}, // {4.08372221499474674069588900002128e-01L, 4.08372221499474674069588900002128e-01L, 4.08372221499474674069588900002128e-01L, 4.04055417266200582425904380777126e-01L}, // {8.59523090201054193116477875786220e-01L, 8.59523090201054193116477875786220e-01L, 4.14735913727987720499709244748633e-01L, 1.24850759678944080062624098058597e-01L} //}; // // const unsigned int rule_id[3] = { //1, // (x,0,0) -> 6 permutations //4, // (x,x,x) -> 8 permutations //5 // (x,x,z) -> 24 permutations // }; // // _points.resize(38); // _weights.resize(38); // // kim_rule(data, rule_id, 3); // return; } // end case SIXTH,SEVENTH case EIGHTH: { // A degree 8, 47-point, "rotationally-symmetric" rule by // Kim and Song, Comm. Korean Math. Soc vol. 13, no. 4, 1998, pp. 913-931. // // A EIGHTH-order Gauss product rule (which integrates tri-8th order polynomials) // would have 5^3=125 points. const Real data[5][4] = { {0.00000000000000000000000000000000e+00L, 0.00000000000000000000000000000000e+00L, 0.00000000000000000000000000000000e+00L, 4.51903714875199690490763818699555e-01L}, {7.82460796435951590652813975429717e-01L, 0.00000000000000000000000000000000e+00L, 0.00000000000000000000000000000000e+00L, 2.99379177352338919703385618576171e-01L}, {4.88094669706366480526729301468686e-01L, 4.88094669706366480526729301468686e-01L, 4.88094669706366480526729301468686e-01L, 3.00876159371240019939698689791164e-01L}, {8.62218927661481188856422891110042e-01L, 8.62218927661481188856422891110042e-01L, 8.62218927661481188856422891110042e-01L, 4.94843255877038125738173175714853e-02L}, {2.81113909408341856058098281846420e-01L, 9.44196578292008195318687494773744e-01L, 6.97574833707236996779391729948984e-01L, 1.22872389222467338799199767122592e-01L} }; const unsigned int rule_id[5] = { 0, // (0,0,0) -> 1 permutation 1, // (x,0,0) -> 6 permutations 4, // (x,x,x) -> 8 permutations 4, // (x,x,x) -> 8 permutations 6 // (x,y,z) -> 24 permutations }; _points.resize(47); _weights.resize(47); kim_rule(data, rule_id, 5); return; } // end case EIGHTH // By default: construct and use a Gauss quadrature rule default: { // Break out and fall down into the default: case for the // outer switch statement. break; } } // end switch(_order + 2*p) } // end case HEX8/20/27 // By default: construct and use a Gauss quadrature rule default: { QGauss gauss_rule(3, _order); gauss_rule.init(type_in, p); // Swap points and weights with the about-to-be destroyed rule. _points.swap (gauss_rule.get_points() ); _weights.swap(gauss_rule.get_weights()); return; } } // end switch (type_in) }