Skip to content
Snippets Groups Projects
Commit 8b669d7b authored by Stéphane Del Pino's avatar Stéphane Del Pino
Browse files

Remove obsolete SimplicialGaussQuadrature files

parent 58b1d75e
No related branches found
No related tags found
1 merge request!124Add files for high order integration with quadratures
Show whitespace changes
Inline Side-by-side
src/analysis/CMakeLists.txt
+ 0
− 1
View file @ 8b669d7b
......@@ -3,7 +3,6 @@
add_library(
PugsAnalysis
CubeGaussQuadrature.cpp
SimplicialGaussQuadrature.cpp
SquareGaussQuadrature.cpp
TensorialGaussLegendreQuadrature.cpp
TensorialGaussLobattoQuadrature.cpp
......
src/analysis/SimplicialGaussQuadrature.cpp deleted 100644 → 0
+ 0
− 1183
View file @ 58b1d75e
#include <analysis/SimplicialGaussQuadrature.hpp>
#include <analysis/TensorialGaussLegendreQuadrature.hpp>
#include <utils/Exceptions.hpp>
template <>
void
SimplicialGaussQuadrature<1>::_buildPointAndWeightLists()
{
TensorialGaussLegendreQuadrature<1> gauss(m_degree);
m_point_list = gauss.pointList();
m_weight_list = gauss.weightList();
}
template <>
void
SimplicialGaussQuadrature<2>::_buildPointAndWeightLists()
{
using R2 = TinyVector<2>;
using Descriptor = std::array<double, 4>;
auto fill_quadrature_points = [](auto descriptor_list, auto& point_list, auto& weight_list) {
Assert(point_list.size() == weight_list.size());
const R2 A = {0, 0};
const R2 B = {1, 0};
const R2 C = {0, 1};
size_t k = 0;
for (size_t i = 0; i < descriptor_list.size(); ++i) {
const auto [unit_weight, lambda_1, lambda_2, lambda_3] = descriptor_list[i];
const double w = 0.5 * unit_weight;
if (lambda_2 == lambda_3) {
if (lambda_1 == lambda_2) {
point_list[k] = lambda_1 * A + lambda_2 * B + lambda_3 * C;
weight_list[k] = w;
k += 1;
} else {
Assert(lambda_1 != lambda_2);
point_list[k + 0] = lambda_1 * A + lambda_2 * B + lambda_3 * C;
point_list[k + 1] = lambda_2 * A + lambda_3 * B + lambda_1 * C;
point_list[k + 2] = lambda_3 * A + lambda_1 * B + lambda_2 * C;
for (size_t i = 0; i < 3; ++i) {
weight_list[k + i] = w;
}
k += 3;
}
} else {
point_list[k + 0] = lambda_1 * A + lambda_2 * B + lambda_3 * C;
point_list[k + 1] = lambda_1 * A + lambda_3 * B + lambda_2 * C;
point_list[k + 2] = lambda_2 * A + lambda_1 * B + lambda_3 * C;
point_list[k + 3] = lambda_2 * A + lambda_3 * B + lambda_1 * C;
point_list[k + 4] = lambda_3 * A + lambda_1 * B + lambda_2 * C;
point_list[k + 5] = lambda_3 * A + lambda_2 * B + lambda_1 * C;
for (size_t i = 0; i < 6; ++i) {
weight_list[k + i] = w;
}
k += 6;
}
}
Assert(k == point_list.size(), "invalid number of quadrature points");
};
switch (m_degree) {
case 0:
case 1: {
constexpr size_t nb_points = 1;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array<Descriptor, 1> descriptor_list = //
{Descriptor{1.000000000000000, 0.333333333333333, 0.333333333333333, 0.333333333333333}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 2: {
constexpr size_t nb_points = 3;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array<Descriptor, 1> descriptor_list = //
{Descriptor{0.333333333333333, 0.666666666666667, 0.166666666666667, 0.166666666666667}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 3: {
constexpr size_t nb_points = 4;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{-0.562500000000000, 0.333333333333333, 0.333333333333333, 0.333333333333333},
Descriptor{+0.520833333333333, 0.600000000000000, 0.200000000000000, 0.200000000000000}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 4: {
constexpr size_t nb_points = 6;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.223381589678011, 0.108103018168070, 0.445948490915965, 0.445948490915965},
Descriptor{0.109951743655322, 0.816847572980459, 0.091576213509771, 0.091576213509771}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 5: {
constexpr size_t nb_points = 7;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.225000000000000, 0.333333333333333, 0.333333333333333, 0.333333333333333},
Descriptor{0.132394152788506, 0.059715871789770, 0.470142064105115, 0.470142064105115},
Descriptor{0.125939180544827, 0.797426985353087, 0.101286507323456, 0.101286507323456}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 6: {
constexpr size_t nb_points = 12;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.116786275726379, 0.501426509658179, 0.249286745170910, 0.249286745170910},
Descriptor{0.050844906370207, 0.873821971016996, 0.063089014491502, 0.063089014491502},
Descriptor{0.082851075618374, 0.053145049844817, 0.310352451033784, 0.636502499121399}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 7: {
constexpr size_t nb_points = 13;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{-0.149570044467682, 0.333333333333333, 0.333333333333333, 0.333333333333333},
Descriptor{+0.175615257433208, 0.479308067841920, 0.260345966079040, 0.260345966079040},
Descriptor{+0.053347235608838, 0.869739794195568, 0.065130102902216, 0.065130102902216},
Descriptor{+0.077113760890257, 0.048690315425316, 0.312865496004874, 0.638444188569810}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 8: {
constexpr size_t nb_points = 16;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.144315607677787, 0.333333333333333, 0.333333333333333, 0.333333333333333},
Descriptor{0.095091634267285, 0.081414823414554, 0.459292588292723, 0.459292588292723},
Descriptor{0.103217370534718, 0.658861384496480, 0.170569307751760, 0.170569307751760},
Descriptor{0.032458497623198, 0.898905543365938, 0.050547228317031, 0.050547228317031},
Descriptor{0.027230314174435, 0.008394777409958, 0.263112829634638, 0.728492392955404}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 9: {
constexpr size_t nb_points = 19;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.097135796282799, 0.333333333333333, 0.333333333333333, 0.333333333333333},
Descriptor{0.031334700227139, 0.020634961602525, 0.489682519198738, 0.489682519198738},
Descriptor{0.077827541004774, 0.125820817014127, 0.437089591492937, 0.437089591492937},
Descriptor{0.079647738927210, 0.623592928761935, 0.188203535619033, 0.188203535619033},
Descriptor{0.025577675658698, 0.910540973211095, 0.044729513394453, 0.044729513394453},
Descriptor{0.043283539377289, 0.036838412054736, 0.221962989160766, 0.741198598784498}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 10: {
constexpr size_t nb_points = 25;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.090817990382754, 0.333333333333333, 0.333333333333333, 0.333333333333333},
Descriptor{0.036725957756467, 0.028844733232685, 0.485577633383657, 0.485577633383657},
Descriptor{0.045321059435528, 0.781036849029926, 0.109481575485037, 0.109481575485037},
Descriptor{0.072757916845420, 0.141707219414880, 0.307939838764121, 0.550352941820999},
Descriptor{0.028327242531057, 0.025003534762686, 0.246672560639903, 0.728323904597411},
Descriptor{0.009421666963733, 0.009540815400299, 0.066803251012200, 0.923655933587500}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 11: {
constexpr size_t nb_points = 27;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.000927006328961, -0.069222096541517, +0.534611048270758, +0.534611048270758},
Descriptor{0.077149534914813, +0.202061394068290, +0.398969302965855, +0.398969302965855},
Descriptor{0.059322977380774, +0.593380199137435, +0.203309900431282, +0.203309900431282},
Descriptor{0.036184540503418, +0.761298175434837, +0.119350912282581, +0.119350912282581},
Descriptor{0.013659731002678, +0.935270103777448, +0.032364948111276, +0.032364948111276},
Descriptor{0.052337111962204, +0.050178138310495, +0.356620648261293, +0.593201213428213},
Descriptor{0.020707659639141, +0.021022016536166, +0.171488980304042, +0.807489003159792}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 12: {
constexpr size_t nb_points = 33;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.025731066440455, 0.023565220452390, 0.488217389773805, 0.488217389773805},
Descriptor{0.043692544538038, 0.120551215411079, 0.439724392294460, 0.439724392294460},
Descriptor{0.062858224217885, 0.457579229975768, 0.271210385012116, 0.271210385012116},
Descriptor{0.034796112930709, 0.744847708916828, 0.127576145541586, 0.127576145541586},
Descriptor{0.006166261051559, 0.957365299093579, 0.021317350453210, 0.021317350453210},
Descriptor{0.040371557766381, 0.115343494534698, 0.275713269685514, 0.608943235779788},
Descriptor{0.022356773202303, 0.022838332222257, 0.281325580989940, 0.695836086787803},
Descriptor{0.017316231108659, 0.025734050548330, 0.116251915907597, 0.858014033544073}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 13: {
constexpr size_t nb_points = 37;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.052520923400802, 0.333333333333333, 0.333333333333333, 0.333333333333333},
Descriptor{0.011280145209330, 0.009903630120591, 0.495048184939705, 0.495048184939705},
Descriptor{0.031423518362454, 0.062566729780852, 0.468716635109574, 0.468716635109574},
Descriptor{0.047072502504194, 0.170957326397447, 0.414521336801277, 0.414521336801277},
Descriptor{0.047363586536355, 0.541200855914337, 0.229399572042831, 0.229399572042831},
Descriptor{0.031167529045794, 0.771151009607340, 0.114424495196330, 0.114424495196330},
Descriptor{0.007975771465074, 0.950377217273082, 0.024811391363459, 0.024811391363459},
Descriptor{0.036848402728732, 0.094853828379579, 0.268794997058761, 0.636351174561660},
Descriptor{0.017401463303822, 0.018100773278807, 0.291730066734288, 0.690169159986905},
Descriptor{0.015521786839045, 0.022233076674090, 0.126357385491669, 0.851409537834241}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 14: {
constexpr size_t nb_points = 42;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.021883581369429, 0.022072179275643, 0.488963910362179, 0.488963910362179},
Descriptor{0.032788353544125, 0.164710561319092, 0.417644719340454, 0.417644719340454},
Descriptor{0.051774104507292, 0.453044943382323, 0.273477528308839, 0.273477528308839},
Descriptor{0.042162588736993, 0.645588935174913, 0.177205532412543, 0.177205532412543},
Descriptor{0.014433699669777, 0.876400233818255, 0.061799883090873, 0.061799883090873},
Descriptor{0.004923403602400, 0.961218077502598, 0.019390961248701, 0.019390961248701},
Descriptor{0.024665753212564, 0.057124757403648, 0.172266687821356, 0.770608554774996},
Descriptor{0.038571510787061, 0.092916249356972, 0.336861459796345, 0.570222290846683},
Descriptor{0.014436308113534, 0.014646950055654, 0.298372882136258, 0.686980167808088},
Descriptor{0.005010228838501, 0.001268330932872, 0.118974497696957, 0.879757171370171}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 15: {
constexpr size_t nb_points = 48;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.001916875642849, -0.013945833716486, +0.506972916858243, +0.506972916858243},
Descriptor{0.044249027271145, +0.137187291433955, +0.431406354283023, +0.431406354283023},
Descriptor{0.051186548718852, +0.444612710305711, +0.277693644847144, +0.277693644847144},
Descriptor{0.023687735870688, +0.747070217917492, +0.126464891041254, +0.126464891041254},
Descriptor{0.013289775690021, +0.858383228050628, +0.070808385974686, +0.070808385974686},
Descriptor{0.004748916608192, +0.962069659517853, +0.018965170241073, +0.018965170241073},
Descriptor{0.038550072599593, +0.133734161966621, +0.261311371140087, +0.604954466893291},
Descriptor{0.027215814320624, +0.036366677396917, +0.388046767090269, +0.575586555512814},
Descriptor{0.002182077366797, -0.010174883126571, +0.285712220049916, +0.724462663076655},
Descriptor{0.021505319847731, +0.036843869875878, +0.215599664072284, +0.747556466051838},
Descriptor{0.007673942631049, +0.012459809331199, +0.103575616576386, +0.883964574092416}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 16: {
constexpr size_t nb_points = 52;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.046875697427642, +0.333333333333333, +0.333333333333333, +0.333333333333333},
Descriptor{0.006405878578585, +0.005238916103123, +0.497380541948438, +0.497380541948438},
Descriptor{0.041710296739387, +0.173061122901295, +0.413469438549352, +0.413469438549352},
Descriptor{0.026891484250064, +0.059082801866017, +0.470458599066991, +0.470458599066991},
Descriptor{0.042132522761650, +0.518892500060958, +0.240553749969521, +0.240553749969521},
Descriptor{0.030000266842773, +0.704068411554854, +0.147965794222573, +0.147965794222573},
Descriptor{0.014200098925024, +0.849069624685052, +0.075465187657474, +0.075465187657474},
Descriptor{0.003582462351273, +0.966807194753950, +0.016596402623025, +0.016596402623025},
Descriptor{0.032773147460627, +0.103575692245252, +0.296555596579887, +0.599868711174861},
Descriptor{0.015298306248441, +0.020083411655416, +0.337723063403079, +0.642193524941505},
Descriptor{0.002386244192839, -0.004341002614139, +0.204748281642812, +0.799592720971327},
Descriptor{0.019084792755899, +0.041941786468010, +0.189358492130623, +0.768699721401368},
Descriptor{0.006850054546542, +0.014317320230681, +0.085283615682657, +0.900399064086661}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 17: {
constexpr size_t nb_points = 61;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.033437199290803, 0.333333333333333, 0.333333333333333, 0.333333333333333},
Descriptor{0.005093415440507, 0.005658918886452, 0.497170540556774, 0.497170540556774},
Descriptor{0.014670864527638, 0.035647354750751, 0.482176322624625, 0.482176322624625},
Descriptor{0.024350878353672, 0.099520061958437, 0.450239969020782, 0.450239969020782},
Descriptor{0.031107550868969, 0.199467521245206, 0.400266239377397, 0.400266239377397},
Descriptor{0.031257111218620, 0.495717464058095, 0.252141267970953, 0.252141267970953},
Descriptor{0.024815654339665, 0.675905990683077, 0.162047004658461, 0.162047004658461},
Descriptor{0.014056073070557, 0.848248235478508, 0.075875882260746, 0.075875882260746},
Descriptor{0.003194676173779, 0.968690546064356, 0.015654726967822, 0.015654726967822},
Descriptor{0.008119655318993, 0.010186928826919, 0.334319867363658, 0.655493203809423},
Descriptor{0.026805742283163, 0.135440871671036, 0.292221537796944, 0.572337590532020},
Descriptor{0.018459993210822, 0.054423924290583, 0.319574885423190, 0.626001190286228},
Descriptor{0.008476868534328, 0.012868560833637, 0.190704224192292, 0.796427214974071},
Descriptor{0.018292796770025, 0.067165782413524, 0.180483211648746, 0.752351005937729},
Descriptor{0.006665632004165, 0.014663182224828, 0.080711313679564, 0.904625504095608}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 18: {
constexpr size_t nb_points = 70;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{+0.030809939937647, +0.333333333333333, +0.333333333333333, +0.333333333333333},
Descriptor{+0.009072436679404, +0.013310382738157, +0.493344808630921, +0.493344808630921},
Descriptor{+0.018761316939594, +0.061578811516086, +0.469210594241957, +0.469210594241957},
Descriptor{+0.019441097985477, +0.127437208225989, +0.436281395887006, +0.436281395887006},
Descriptor{+0.027753948610810, +0.210307658653168, +0.394846170673416, +0.394846170673416},
Descriptor{+0.032256225351457, +0.500410862393686, +0.249794568803157, +0.249794568803157},
Descriptor{+0.025074032616922, +0.677135612512315, +0.161432193743843, +0.161432193743843},
Descriptor{+0.015271927971832, +0.846803545029257, +0.076598227485371, +0.076598227485371},
Descriptor{+0.006793922022963, +0.951495121293100, +0.024252439353450, +0.024252439353450},
Descriptor{-0.002223098729920, +0.913707265566071, +0.043146367216965, +0.043146367216965},
Descriptor{+0.006331914076406, +0.008430536202420, +0.358911494940944, +0.632657968856636},
Descriptor{+0.027257538049138, +0.131186551737188, +0.294402476751957, +0.574410971510855},
Descriptor{+0.017676785649465, +0.050203151565675, +0.325017801641814, +0.624779046792512},
Descriptor{+0.018379484638070, +0.066329263810916, +0.184737559666046, +0.748933176523037},
Descriptor{+0.008104732808192, +0.011996194566236, +0.218796800013321, +0.769207005420443},
Descriptor{+0.007634129070725, +0.014858100590125, +0.101179597136408, +0.883962302273467},
Descriptor{+0.000046187660794, -0.035222015287949, +0.020874755282586, +1.014347260005363}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 19: {
constexpr size_t nb_points = 73;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{0.032906331388919, 0.333333333333333, 0.333333333333333, 0.333333333333333},
Descriptor{0.010330731891272, 0.020780025853987, 0.489609987073006, 0.489609987073006},
Descriptor{0.022387247263016, 0.090926214604215, 0.454536892697893, 0.454536892697893},
Descriptor{0.030266125869468, 0.197166638701138, 0.401416680649431, 0.401416680649431},
Descriptor{0.030490967802198, 0.488896691193805, 0.255551654403098, 0.255551654403098},
Descriptor{0.024159212741641, 0.645844115695741, 0.177077942152130, 0.177077942152130},
Descriptor{0.016050803586801, 0.779877893544096, 0.110061053227952, 0.110061053227952},
Descriptor{0.008084580261784, 0.888942751496321, 0.055528624251840, 0.055528624251840},
Descriptor{0.002079362027485, 0.974756272445543, 0.012621863777229, 0.012621863777229},
Descriptor{0.003884876904981, 0.003611417848412, 0.395754787356943, 0.600633794794645},
Descriptor{0.025574160612022, 0.134466754530780, 0.307929983880436, 0.557603261588784},
Descriptor{0.008880903573338, 0.014446025776115, 0.264566948406520, 0.720987025817365},
Descriptor{0.016124546761731, 0.046933578838178, 0.358539352205951, 0.594527068955871},
Descriptor{0.002491941817491, 0.002861120350567, 0.157807405968595, 0.839331473680839},
Descriptor{0.018242840118951, 0.223861424097916, 0.075050596975911, 0.701087978926173},
Descriptor{0.010258563736199, 0.034647074816760, 0.142421601113383, 0.822931324069857},
Descriptor{0.003799928855302, 0.010161119296278, 0.065494628082938, 0.924344252620784}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 20: {
constexpr size_t nb_points = 79;
SmallArray<R2> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{+0.033057055541624, +0.333333333333333, +0.333333333333333, +0.333333333333333},
Descriptor{+0.000867019185663, -0.001900928704400, +0.500950464352200, +0.500950464352200},
Descriptor{+0.011660052716448, +0.023574084130543, +0.488212957934729, +0.488212957934729},
Descriptor{+0.022876936356421, +0.089726636099435, +0.455136681950283, +0.455136681950283},
Descriptor{+0.030448982673938, +0.196007481363421, +0.401996259318289, +0.401996259318289},
Descriptor{+0.030624891725355, +0.488214180481157, +0.255892909759421, +0.255892909759421},
Descriptor{+0.024368057676800, +0.647023488009788, +0.176488255995106, +0.176488255995106},
Descriptor{+0.015997432032024, +0.791658289326483, +0.104170855336758, +0.104170855336758},
Descriptor{+0.007698301815602, +0.893862072318140, +0.053068963840930, +0.053068963840930},
Descriptor{-0.000632060497488, +0.916762569607942, +0.041618715196029, +0.041618715196029},
Descriptor{+0.001751134301193, +0.976836157186356, +0.011581921406822, +0.011581921406822},
Descriptor{+0.016465839189576, +0.048741583664839, +0.344855770229001, +0.606402646106160},
Descriptor{+0.004839033540485, +0.006314115948605, +0.377843269594854, +0.615842614456541},
Descriptor{+0.025804906534650, +0.134316520547348, +0.306635479062357, +0.559048000390295},
Descriptor{+0.008471091054441, +0.013973893962392, +0.249419362774742, +0.736606743262866},
Descriptor{+0.018354914106280, +0.075549132909764, +0.212775724802802, +0.711675142287434},
Descriptor{+0.000704404677908, -0.008368153208227, +0.146965436053239, +0.861402717154987},
Descriptor{+0.010112684927462, +0.026686063258714, +0.137726978828923, +0.835586957912363},
Descriptor{+0.003573909385950, +0.010547719294141, +0.059696109149007, +0.929756171556853}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
default: {
throw NormalError("Gauss quadrature formulae handle degrees up to 20 on triangles");
}
}
}
template <>
void
SimplicialGaussQuadrature<3>::_buildPointAndWeightLists()
{
using R3 = TinyVector<3>;
struct Descriptor
{
int id;
double weight;
std::vector<double> lambda_list;
};
auto fill_quadrature_points = [](auto descriptor_list, auto& point_list, auto& weight_list) {
Assert(point_list.size() == weight_list.size());
const R3 A = {0, 0, 0};
const R3 B = {1, 0, 0};
const R3 C = {0, 1, 0};
const R3 D = {0, 0, 1};
size_t k = 0;
for (size_t i = 0; i < descriptor_list.size(); ++i) {
const auto [id, unit_weight, lambda_list] = descriptor_list[i];
const double w = (1. / 6) * unit_weight;
switch (id) {
case 1: {
Assert(lambda_list.size() == 0);
point_list[k] = (1. / 4) * (A + B + C + D);
weight_list[k] = w;
++k;
break;
}
case 2: {
Assert(lambda_list.size() == 1);
const double l0 = lambda_list[0];
const double l1 = 1 - 3 * l0;
point_list[k + 0] = l0 * A + l0 * B + l0 * C + l1 * D;
point_list[k + 1] = l0 * A + l0 * B + l1 * C + l0 * D;
point_list[k + 2] = l0 * A + l1 * B + l0 * C + l0 * D;
point_list[k + 3] = l1 * A + l0 * B + l0 * C + l0 * D;
for (size_t l = 0; l < 4; ++l) {
weight_list[k + l] = w;
}
k += 4;
break;
}
case 3: {
Assert(lambda_list.size() == 2);
const double l0 = lambda_list[0];
const double l1 = 0.5 - l0;
point_list[k + 0] = l0 * A + l0 * B + l1 * C + l1 * D;
point_list[k + 1] = l0 * A + l1 * B + l0 * C + l1 * D;
point_list[k + 2] = l0 * A + l1 * B + l1 * C + l0 * D;
point_list[k + 3] = l1 * A + l0 * B + l0 * C + l1 * D;
point_list[k + 4] = l1 * A + l0 * B + l1 * C + l0 * D;
point_list[k + 5] = l1 * A + l1 * B + l0 * C + l0 * D;
for (size_t l = 0; l < 6; ++l) {
weight_list[k + l] = w;
}
k += 6;
break;
}
case 4: {
Assert(lambda_list.size() == 2);
const double l0 = lambda_list[0];
const double l1 = lambda_list[1];
const double l2 = 1 - 2 * l0 - l1;
point_list[k + 0] = l0 * A + l0 * B + l1 * C + l2 * D;
point_list[k + 1] = l0 * A + l0 * B + l2 * C + l1 * D;
point_list[k + 2] = l0 * A + l1 * B + l0 * C + l2 * D;
point_list[k + 3] = l0 * A + l1 * B + l2 * C + l0 * D;
point_list[k + 4] = l0 * A + l2 * B + l0 * C + l1 * D;
point_list[k + 5] = l0 * A + l2 * B + l1 * C + l0 * D;
point_list[k + 6] = l1 * A + l0 * B + l0 * C + l2 * D;
point_list[k + 7] = l1 * A + l0 * B + l2 * C + l0 * D;
point_list[k + 8] = l1 * A + l2 * B + l0 * C + l0 * D;
point_list[k + 9] = l2 * A + l0 * B + l0 * C + l1 * D;
point_list[k + 10] = l2 * A + l0 * B + l1 * C + l0 * D;
point_list[k + 11] = l2 * A + l1 * B + l0 * C + l0 * D;
for (size_t l = 0; l < 12; ++l) {
weight_list[k + l] = w;
}
k += 12;
break;
}
case 5: {
Assert(lambda_list.size() == 3);
const double l0 = lambda_list[0];
const double l1 = lambda_list[1];
const double l2 = lambda_list[2];
const double l3 = 1 - l0 - l1 - l2;
point_list[k + 0] = l0 * A + l1 * B + l2 * C + l3 * D;
point_list[k + 1] = l0 * A + l1 * B + l3 * C + l2 * D;
point_list[k + 2] = l0 * A + l2 * B + l1 * C + l3 * D;
point_list[k + 3] = l0 * A + l2 * B + l3 * C + l1 * D;
point_list[k + 4] = l0 * A + l3 * B + l1 * C + l2 * D;
point_list[k + 5] = l0 * A + l3 * B + l2 * C + l1 * D;
point_list[k + 6] = l1 * A + l0 * B + l2 * C + l3 * D;
point_list[k + 7] = l1 * A + l0 * B + l3 * C + l2 * D;
point_list[k + 8] = l1 * A + l2 * B + l0 * C + l3 * D;
point_list[k + 9] = l1 * A + l2 * B + l3 * C + l0 * D;
point_list[k + 10] = l1 * A + l3 * B + l0 * C + l2 * D;
point_list[k + 11] = l1 * A + l3 * B + l2 * C + l0 * D;
point_list[k + 12] = l2 * A + l0 * B + l1 * C + l3 * D;
point_list[k + 13] = l2 * A + l0 * B + l3 * C + l1 * D;
point_list[k + 14] = l2 * A + l1 * B + l0 * C + l3 * D;
point_list[k + 15] = l2 * A + l1 * B + l3 * C + l0 * D;
point_list[k + 16] = l2 * A + l3 * B + l0 * C + l1 * D;
point_list[k + 17] = l2 * A + l3 * B + l1 * C + l0 * D;
point_list[k + 18] = l3 * A + l0 * B + l1 * C + l2 * D;
point_list[k + 19] = l3 * A + l0 * B + l2 * C + l1 * D;
point_list[k + 20] = l3 * A + l1 * B + l0 * C + l2 * D;
point_list[k + 21] = l3 * A + l1 * B + l2 * C + l0 * D;
point_list[k + 22] = l3 * A + l2 * B + l0 * C + l1 * D;
point_list[k + 23] = l3 * A + l2 * B + l1 * C + l0 * D;
for (size_t l = 0; l < 24; ++l) {
weight_list[k + l] = w;
}
k += 24;
break;
}
default: {
throw UnexpectedError("invalid quadrature id");
}
}
}
};
switch (m_degree) {
case 0:
case 1: {
constexpr size_t nb_points = 1;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{1, 1.000000000000000e+00, {}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 2: {
constexpr size_t nb_points = 4;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 2.500000000000000e-01, {1.381966011250105e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 3: {
constexpr size_t nb_points = 8;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 1.274913115575064e-01, {3.286811466653490e-01}},
Descriptor{2, 1.225086884424936e-01, {1.119207275092916e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 4: {
constexpr size_t nb_points = 14;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 6.540916363445218e-02, {3.095821653179519e-01}},
Descriptor{2, 5.935526423100475e-02, {8.344277230397758e-02}},
Descriptor{3, 8.349038142302871e-02, {4.227790459299413e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 5: {
constexpr size_t nb_points = 14;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 1.126879257180158e-01, {3.108859192633006e-01}},
Descriptor{2, 7.349304311636196e-02, {9.273525031089122e-02}},
Descriptor{3, 4.254602077708147e-02, {4.544962958743504e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 6: {
constexpr size_t nb_points = 24;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 1.007721105532064e-02, {4.067395853461135e-02}},
Descriptor{2, 5.535718154365472e-02, {3.223378901422755e-01}},
Descriptor{2, 3.992275025816749e-02, {2.146028712591520e-01}},
Descriptor{4, 4.821428571428572e-02, {6.366100187501753e-02, 6.030056647916492e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 7: {
constexpr size_t nb_points = 35;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{1, 9.548528946413085e-02, {}}, Descriptor{2, 4.232958120996703e-02, {3.157011497782028e-01}},
Descriptor{3, 3.189692783285758e-02, {4.495101774016036e-01}},
Descriptor{4, 8.110770829903342e-03, {2.126547254148325e-02, 8.108302410985485e-01}},
Descriptor{4, 3.720713072833462e-02, {1.888338310260010e-01, 5.751716375870001e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 8: {
constexpr size_t nb_points = 46;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 4.781298803430666e-02, {1.868127582707210e-01}},
Descriptor{2, 2.972785408679422e-02, {1.144624067612305e-01}},
Descriptor{2, 4.352732421897527e-02, {3.138065922724016e-01}},
Descriptor{2, 8.632736020814975e-03, {4.457737944884625e-02}},
Descriptor{3, 3.689054126986636e-02, {6.548349054384239e-02}},
Descriptor{4, 1.449702671085950e-02, {2.038931746621103e-01, 5.073320750421590e-03}},
Descriptor{4, 7.157401867243608e-03, {2.124777966957167e-02, 7.146769263933049e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 9: {
constexpr size_t nb_points = 59;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{1, 5.686662425355173e-02, {}},
Descriptor{2, 2.569427668952318e-02, {1.679066052367428e-01}},
Descriptor{2, 2.298923353028370e-03, {9.143627051407625e-02}},
Descriptor{2, 3.045603866759101e-02, {3.218556648176533e-01}},
Descriptor{2, 7.123722340238881e-03, {4.183769590036560e-02}},
Descriptor{3, 3.684365548094388e-02, {1.067294385748464e-01}},
Descriptor{4, 1.032205678220985e-02, {3.395716818308889e-02, 7.183930939814244e-01}},
Descriptor{4, 7.634887153980855e-03, {4.606581810547776e-01, 7.868363447668793e-02}},
Descriptor{4, 2.035802261874757e-02, {1.843879435000152e-01, 5.972107227618499e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 10: {
constexpr size_t nb_points = 81;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{1, 5.165089225609747e-02, {}},
Descriptor{2, 1.346797267166026e-02, {7.255175741743780e-02}},
Descriptor{2, 2.646691924968953e-02, {3.078959478669229e-01}},
Descriptor{3, 5.107047828143525e-03, {2.371913960722093e-02}},
Descriptor{3, 2.364999615824560e-02, {4.034202269308927e-01}},
Descriptor{4, 2.531736665096822e-02, {2.017386068476799e-01, 7.385418101848620e-02}},
Descriptor{4, 5.416263407447926e-03, {1.548397007438618e-01, 6.875048558830396e-01}},
Descriptor{4, 8.153659012054226e-03, {4.125991504993639e-01, 1.741437164939321e-01}},
Descriptor{4, 1.112597175961278e-02, {3.889072755780651e-02, 2.657575065627199e-01}},
Descriptor{4, 1.325678848264236e-03, {5.604847951021338e-03, 9.324134903525841e-02}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 11: {
constexpr size_t nb_points = 110;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 1.468934358613075e-02, {2.993130923993425e-01}},
Descriptor{2, 3.380869530621681e-03, {3.263284396518180e-02}},
Descriptor{3, 1.676676867722563e-02, {1.742044154846892e-01}},
Descriptor{3, 1.932364034775851e-02, {4.012153758583749e-01}},
Descriptor{3, 1.653253610375797e-03, {4.942980948772996e-01}},
Descriptor{4, 9.799971247032874e-03, {1.231206549747224e-01, 7.273303463463835e-01}},
Descriptor{4, 2.036278491304826e-03, {1.300387048559024e-02, 1.702280734892642e-01}},
Descriptor{4, 8.207613752916718e-03, {4.293540117192574e-02, 6.182598097891158e-01}},
Descriptor{4, 1.510498736666349e-02, {1.844240320470778e-01, 5.399001168557016e-01}},
Descriptor{4, 1.274239266610639e-02, {2.591694074642826e-01, 4.554353196219595e-01}},
Descriptor{5, 5.273427059689129e-03, {5.351420009314595e-01, 1.097757236596031e-02, 3.414518661958190e-01}}
};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 12: {
constexpr size_t nb_points = 168;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 1.761491553503257e-02, {2.135679944533018e-01}},
Descriptor{2, 8.351235933432746e-03, {8.080469951147343e-02}},
Descriptor{2, 1.777571920669439e-02, {1.460894685275485e-01}},
Descriptor{3, 1.016802439757214e-02, {4.359346229622011e-01}},
Descriptor{3, 1.574040002395383e-02, {3.723816950753983e-01}},
Descriptor{4, 1.511281145864287e-03, {1.481472606744865e-02, 6.940351772721454e-01}},
Descriptor{4, 8.726569887485608e-04, {4.406791967562980e-02, 5.787943875724942e-04}},
Descriptor{4, 3.712882661457528e-03, {2.900481455515819e-02, 7.927838364729656e-01}},
Descriptor{4, 2.358314255727376e-03, {1.384125788015036e-01, 7.217318354185758e-01}},
Descriptor{5, 4.490847036271700e-03, {1.155183527100142e-02, 2.002685156661767e-01, 4.459556015690982e-01}},
Descriptor{5, 7.549616048899519e-03, {7.295863195082626e-02, 2.545920450251540e-01, 4.229332866644536e-01}},
Descriptor{5, 1.850514589067692e-03, {5.001810761518710e-02, 3.937338659984053e-01, 5.538497716858680e-01}},
Descriptor{5, 9.780703581954099e-03, {2.518367824271116e-01, 3.608735666657864e-02, 5.985486290544021e-01}}
};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 13: {
constexpr size_t nb_points = 172;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 8.606417789141471e-04, {2.023816786180974e-02}},
Descriptor{2, 2.260732681773922e-02, {2.890147352435263e-01}},
Descriptor{2, 9.680037326838918e-03, {9.402870008212708e-02}},
Descriptor{2, 7.170940325572750e-03, {1.976498544437255e-01}},
Descriptor{3, 7.784870979280401e-03, {4.046189676018364e-02}},
Descriptor{3, 5.120271481716123e-04, {4.999998048519694e-01}},
Descriptor{4, 8.880272171422971e-03, {6.752926495280243e-02, 6.118971302042935e-01}},
Descriptor{4, 1.062144779049374e-02, {1.360105145132029e-01, 4.868308338798159e-01}},
Descriptor{4, 5.873089331995857e-03, {2.780783459563702e-01, 4.273786080349000e-01}},
Descriptor{4, 9.235535397556015e-03, {1.967550197192861e-01, 5.667528680967985e-01}},
Descriptor{4, 1.456732207916522e-02, {3.862498629203497e-01, 6.201970724197543e-02}},
Descriptor{4, 2.658739862173390e-03, {2.353551905465277e-02, 1.086607820833199e-01}},
Descriptor{5, 3.221852775001763e-03, {3.362108930747719e-01, 5.446964977019162e-01, 1.155925493534321e-01}},
Descriptor{5, 1.464206741103990e-03, {6.859816301235152e-01, 2.886160494075550e-02, 2.745833302490004e-01}},
Descriptor{5, 2.268354927450138e-03, {7.356772467818598e-01, 1.545866468273804e-01, 1.103371356908743e-02}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 14: {
constexpr size_t nb_points = 204;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 3.445433050323388e-03, {3.298151517846193e-01}},
Descriptor{2, 2.621255271870497e-03, {5.753828268975920e-02}},
Descriptor{2, 1.107383241893503e-04, {5.856168613783504e-03}},
Descriptor{2, 1.002858537247380e-02, {1.605554758479567e-01}},
Descriptor{2, 6.790408457809412e-03, {9.873964607404909e-02}},
Descriptor{2, 7.118148341899285e-03, {2.080531961597265e-01}},
Descriptor{3, 1.060052294564051e-03, {4.902479711877765e-01}},
Descriptor{3, 1.366983099498089e-02, {1.029394001155326e-01}},
Descriptor{3, 2.690741094676155e-03, {3.791346346121514e-02}},
Descriptor{3, 1.016460122584274e-02, {3.185735761838604e-01}},
Descriptor{4, 1.354439963772740e-02, {2.499092188634998e-01, 4.189387788376669e-01}},
Descriptor{4, 4.623340047669791e-03, {2.132633780618757e-01, 5.628766802497838e-01}},
Descriptor{4, 8.331498452473301e-04, {4.918128494015905e-02, 8.954689727140162e-01}},
Descriptor{4, 7.240296760857249e-03, {3.928626179700601e-01, 2.066357892967347e-02}},
Descriptor{4, 8.751807809978078e-04, {1.261760553257071e-02, 1.269022024074958e-01}},
Descriptor{5, 7.172536518098438e-03, {1.216187843486990e-01, 6.214000311762153e-02, 2.395005950785847e-01}},
Descriptor{5, 4.286856342790781e-03, {3.489022960470246e-01, 5.517941321184247e-01, 8.378145261134291e-02}},
Descriptor{5, 9.757527641506894e-04, {6.822383201682893e-01, 1.784164064765456e-02, 2.844407418708836e-01}},
Descriptor{5, 3.757936299766722e-03, {7.339982986585810e-01, 1.695395507001622e-01, 7.868554787111390e-02}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 15: {
constexpr size_t nb_points = 264;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 5.112029771454935e-04, {1.692642158547220e-02}},
Descriptor{2, 1.620740592022658e-02, {2.836779254595722e-01}},
Descriptor{2, 1.552578602041314e-02, {1.821984139975859e-01}},
Descriptor{3, 1.219010259975421e-03, {1.450800515218459e-02}},
Descriptor{3, 8.472862853125917e-03, {1.427441437658564e-01}},
Descriptor{4, 1.797534305405733e-03, {7.321727256195354e-02, 7.766357493733004e-01}},
Descriptor{4, 8.198015220760061e-04, {1.056558410489699e-02, 2.225606554924344e-01}},
Descriptor{4, 7.681775272473012e-03, {2.637972626688146e-01, 5.575022240565973e-02}},
Descriptor{4, 4.479850385774781e-03, {4.354902702993817e-01, 1.112909267055329e-01}},
Descriptor{4, 5.615298608384355e-03, {5.347259364185193e-02, 5.448865322975603e-01}},
Descriptor{4, 1.769703685797290e-03, {1.105308939580100e-01, 7.694703779405406e-01}},
Descriptor{5, 1.131138329187022e-03, {4.104670514991076e-02, 6.030936440770986e-01, 2.328924415481402e-03}},
Descriptor{5, 8.404993407577487e-04, {9.201667327695258e-02, 2.939319332917082e-02, 8.672646051241815e-01}},
Descriptor{5, 3.011968607402684e-03, {6.822627868000052e-02, 7.077814873155971e-01, 2.200643755861662e-02}},
Descriptor{5, 5.084429327522668e-03, {1.890015556386176e-01, 1.295809597674534e-01, 6.807532978800637e-02}},
Descriptor{5, 7.139383728003996e-03, {3.054799663906012e-01, 4.695333003662676e-01, 7.251484323369149e-02}},
Descriptor{5, 3.378550568229294e-03, {1.509145500825105e-01, 5.778346261482753e-01, 1.112774031280626e-02}},
Descriptor{5, 2.201680777701462e-03, {3.368450658547645e-01, 1.082194753682293e-02, 4.176069528643034e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 16: {
constexpr size_t nb_points = 304;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 4.034878937238870e-03, {3.296714738440606e-01}},
Descriptor{2, 5.263428008047628e-03, {1.120421044173788e-01}},
Descriptor{2, 1.078639106857764e-02, {2.804460259110929e-01}},
Descriptor{2, 1.892340029030997e-03, {3.942164444076166e-02}},
Descriptor{3, 6.014511003000459e-03, {7.491741856476755e-02}},
Descriptor{3, 8.692191232873023e-03, {3.356931029556346e-01}},
Descriptor{4, 3.507623285784993e-03, {4.904898759556675e-02, 7.646870675801803e-01}},
Descriptor{4, 1.188662273319198e-03, {1.412609568309253e-02, 2.328268045894251e-01}},
Descriptor{4, 4.345225314466667e-03, {6.239652058154325e-02, 2.832417683077947e-01}},
Descriptor{4, 2.660686570203166e-03, {1.890959275696560e-01, 1.283187405611824e-02}},
Descriptor{4, 5.553174302124013e-03, {2.750176001295444e-01, 3.872709603194903e-01}},
Descriptor{4, 1.531431405395808e-04, {5.944898252569946e-03, 3.723805935523542e-02}},
Descriptor{4, 2.231204136715679e-03, {1.183058071099944e-01, 7.482941078308859e-01}},
Descriptor{5, 2.472377156249970e-03, {8.011846127872502e-02, 5.146357887888395e-01, 3.908021114187921e-01}},
Descriptor{5, 6.596122891817925e-03, {3.102585498627273e-01, 1.645739468379099e-01, 6.995093322963369e-02}},
Descriptor{5, 6.004349067697421e-04, {1.085240801928985e-01, 3.435867950145696e-02, 8.557156992205752e-01}},
Descriptor{5, 2.242330996876527e-03, {2.483824987814955e-01, 6.625317544850510e-01, 1.098323448764900e-02}},
Descriptor{5, 8.244422362471837e-04, {3.960091211067035e-01, 1.226898678006519e-02, 1.878187449597510e-02}},
Descriptor{5, 4.388015835267911e-03, {6.367516197137306e-02, 2.054604991324105e-01, 1.362449508885895e-01}},
Descriptor{5, 3.454278425740962e-03, {1.757650466139104e-01, 4.610678860796995e-01, 1.387535709612253e-01}},
Descriptor{5, 3.929289473335571e-03, {4.779942532006705e-01, 1.344788610299629e-02, 3.221398306538996e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 17: {
constexpr size_t nb_points = 364;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 2.943411054682655e-03, {1.092594110391400e-01}},
Descriptor{2, 4.821254562130973e-04, {1.706905335350991e-02}},
Descriptor{2, 1.633411882335971e-03, {6.030276440208671e-02}},
Descriptor{2, 8.937260544733967e-03, {1.802936778752487e-01}},
Descriptor{3, 3.539281041131444e-03, {2.075642494319923e-01}},
Descriptor{3, 5.127876775122913e-03, {6.350561875036179e-02}},
Descriptor{3, 8.505961705776655e-03, {1.425740948569834e-01}},
Descriptor{3, 1.362001059565090e-03, {1.525498961135818e-02}},
Descriptor{4, 1.952703594699083e-03, {2.817717468661823e-01, 6.605628545936354e-03}},
Descriptor{4, 3.552482332702156e-03, {2.532792896616394e-01, 3.473076755269789e-01}},
Descriptor{4, 4.735037872087881e-03, {1.194446836887992e-01, 5.129631932135305e-01}},
Descriptor{4, 4.076204052523780e-03, {2.796975892179978e-01, 4.040135150131379e-01}},
Descriptor{4, 4.397889616038591e-03, {5.914965001755916e-02, 2.771505768037979e-01}},
Descriptor{4, 8.159915418039479e-04, {1.156645687972039e-02, 3.372693231713962e-01}},
Descriptor{4, 6.436927403356441e-03, {2.546200946118619e-01, 8.899213511967391e-02}},
Descriptor{4, 2.290937029978224e-04, {6.672914677865158e-03, 8.335377000797282e-02}},
Descriptor{4, 3.188746694204980e-03, {5.954996366173630e-02, 1.488738514609226e-01}},
Descriptor{5, 1.991266259969879e-03, {9.563829425828949e-02, 1.308047471312760e-02, 1.683493064182302e-01}},
Descriptor{5, 1.209946636868781e-03, {6.035751534893870e-02, 6.376551993416253e-01, 1.062246299591423e-02}},
Descriptor{5, 2.943417982183902e-03, {5.720629662753272e-01, 1.575062824084584e-01, 1.289545879798304e-02}},
Descriptor{5, 3.454094554810564e-03, {5.982871618499548e-01, 1.530963612221368e-01, 6.489065131906320e-02}},
Descriptor{5, 8.241135414777571e-04, {8.721077921772252e-02, 1.165500297046612e-02, 4.707766223753580e-02}},
Descriptor{5, 1.383542378170185e-03, {4.137799680661914e-01, 4.085328910163256e-01, 1.048009320013415e-02}},
Descriptor{5, 1.781445235926538e-03, {3.904989583719425e-01, 1.167932299246964e-02, 7.360595669274642e-02}},
Descriptor{5, 6.969316351001401e-04, {7.735017403534717e-01, 8.163680371232981e-03, 2.545430962429988e-02}},
Descriptor{5, 5.722888401891606e-03, {5.603440494408158e-02, 1.529886055031752e-01, 3.226986469260043e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 18: {
constexpr size_t nb_points = 436;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 1.505388406750596e-03, {2.063721818681210e-01}},
Descriptor{2, 7.201441531528436e-03, {1.625387945176406e-01}},
Descriptor{2, 5.801801233694815e-03, {3.116266728255643e-01}},
Descriptor{2, 2.465088392849791e-03, {3.307279160890313e-01}},
Descriptor{2, 8.235271059110021e-04, {3.374408201299506e-02}},
Descriptor{2, 2.396153395824959e-03, {6.568138278425954e-02}},
Descriptor{2, 1.662026538062453e-04, {1.169072420259711e-02}},
Descriptor{3, 4.747626606883917e-05, {3.051729141214794e-01}},
Descriptor{3, 5.654960404175805e-04, {2.498171653415399e-01}},
Descriptor{3, 1.126644847587598e-03, {1.336652291605620e-02}},
Descriptor{3, 1.348246151880201e-03, {2.503423435758855e-01}},
Descriptor{3, 3.657069096677683e-04, {3.324517722542840e-01}},
Descriptor{3, 5.853171992565114e-03, {3.328935974705466e-01}},
Descriptor{3, 1.956691034821430e-03, {1.053889982941293e-01}},
Descriptor{3, 1.673244252179039e-03, {4.317721941366494e-02}},
Descriptor{4, 1.684409973125634e-03, {3.310306761504429e-02, 1.352754021303201e-01}},
Descriptor{4, 9.489733030971150e-04, {1.946185784467675e-01, 1.171879047047253e-03}},
Descriptor{4, 1.039083135931653e-03, {1.321252126131118e-02, 3.278960098149503e-01}},
Descriptor{4, 2.868558324240348e-03, {1.229320721770598e-01, 2.028399843152170e-02}},
Descriptor{4, 3.672202784572132e-03, {6.199506095168380e-02, 3.498961219623653e-01}},
Descriptor{4, 4.747155546596363e-03, {8.407187546991698e-02, 1.666830796952924e-01}},
Descriptor{4, 4.150884078212972e-04, {7.867048874453891e-03, 1.859179591228751e-01}},
Descriptor{4, 2.504990122247683e-03, {4.217582498871236e-02, 2.482707411503117e-01}},
Descriptor{4, 2.629919627710238e-04, {8.683491872138840e-03, 6.698102226768764e-02}},
Descriptor{4, 5.237948818645674e-03, {1.111185367576208e-01, 2.918417077981162e-01}},
Descriptor{5, 9.530517345502799e-04, {3.685463845606022e-03, 6.377078964518405e-02, 2.161982818015302e-01}},
Descriptor{5, 4.424079498028044e-04, {9.147563979493070e-02, 4.024098103223798e-03, 4.866034767929566e-02}},
Descriptor{5, 1.756179008422938e-03, {1.326563740184036e-01, 4.168774597385260e-01, 2.814320586294362e-02}},
Descriptor{5, 2.434266881750153e-03, {4.439198669278809e-01, 2.464330224801677e-01, 2.919443405619611e-02}},
Descriptor{5, 3.936511965938193e-03, {2.395450885895190e-01, 1.271207488070096e-01, 2.457574497117561e-01}},
Descriptor{5, 3.199791269106457e-03, {1.657130887168779e-01, 2.137049061861850e-01, 7.023964653694080e-02}},
Descriptor{5, 3.797610312158748e-03, {1.788776686026366e-01, 3.290353014877974e-01, 6.661063766146717e-02}},
Descriptor{5, 1.495938562630981e-03, {3.340176116726106e-01, 4.950315956949369e-03, 1.887999372824127e-01}},
Descriptor{5, 1.703996181224725e-03, {5.458773009126385e-01, 7.846288361681254e-03, 7.104964990519175e-02}},
Descriptor{5, 3.628775117699059e-03, {2.510439859007851e-02, 1.293557534662013e-01, 2.529882400374321e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 19: {
constexpr size_t nb_points = 487;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{1, 9.477424964421555e-03, {}},
Descriptor{2, 2.309652046579032e-03, {9.623346794170115e-02}},
Descriptor{2, 4.091492762240734e-03, {2.840710971185555e-01}},
Descriptor{2, 1.173654667448287e-03, {4.201218049762310e-02}},
Descriptor{3, 5.797759302818667e-03, {1.293925012179526e-01}},
Descriptor{4, 2.028992639106921e-03, {5.339312125330306e-02, 7.679699947393867e-01}},
Descriptor{4, 2.005858485106433e-04, {5.250553906919603e-03, 1.660339253205299e-01}},
Descriptor{4, 2.908059972456899e-03, {2.128993323694659e-01, 1.034045995093328e-01}},
Descriptor{4, 2.532078463287134e-03, {4.034135325977229e-01, 1.333356346432022e-01}},
Descriptor{4, 7.343695736316139e-04, {1.188811930811271e-02, 5.532379678070896e-01}},
Descriptor{4, 1.076183574539400e-03, {8.903116551206627e-02, 8.080695151909102e-01}},
Descriptor{4, 1.986415677131464e-03, {5.151678695899160e-02, 4.873280365294901e-01}},
Descriptor{4, 5.046317364293947e-03, {1.179992852297671e-01, 2.466149943644083e-01}},
Descriptor{4, 2.692282460531053e-03, {4.608512334928590e-02, 2.781414318856127e-01}},
Descriptor{4, 1.330636288503801e-03, {1.410186708097898e-01, 8.174649948389451e-03}},
Descriptor{4, 1.782928900852855e-03, {1.411034408699267e-01, 5.855868767598970e-01}},
Descriptor{4, 1.263015826184454e-04, {7.911862204821108e-03, 3.035883809061935e-02}},
Descriptor{4, 3.244260943819173e-03, {1.761012114703174e-01, 2.461239587816849e-01}},
Descriptor{5, 1.048498185712524e-03, {4.531137441520981e-02, 7.694124041149815e-01, 1.162671237541303e-02}},
Descriptor{5, 3.605740745734604e-03, {1.902469770309511e-01, 1.139907343389768e-01, 4.902896398807803e-02}},
Descriptor{5, 2.561558407869844e-03, {2.025882107314621e-01, 5.045224197189542e-01, 5.200356315054191e-02}},
Descriptor{5, 1.498918467834416e-03, {6.280459865457699e-02, 3.899342137938394e-01, 9.651021927014570e-03}},
Descriptor{5, 1.814324572327483e-03, {1.689034611068301e-01, 1.025101977116908e-02, 2.542260337897459e-01}},
Descriptor{5, 2.883938073996170e-03, {1.282802298826546e-01, 3.714709314621824e-01, 2.826241348940526e-01}},
Descriptor{5, 3.191411305221261e-03, {3.753164302248334e-01, 2.323738231259893e-01, 5.648574604597608e-02}},
Descriptor{5, 3.955282336986757e-04, {8.176634693298535e-02, 2.823323910477210e-02, 8.840321921276471e-01}},
Descriptor{5, 1.642211231915762e-03, {3.727215008878210e-01, 4.691373442926859e-01, 1.052014400647361e-02}},
Descriptor{5, 4.640920897459689e-04, {2.881077012617455e-01, 6.241150434253934e-03, 2.040787180394686e-02}},
Descriptor{5, 1.210865339994028e-03, {8.483677030488673e-03, 2.548571009364550e-01, 8.369886684600136e-02}},
Descriptor{5, 3.653283017278065e-03, {1.193128036212033e-01, 5.081225906571617e-01, 5.013138003585081e-02}},
Descriptor{5, 1.744791238762615e-03, {4.198369201417426e-01, 1.094996106379021e-02, 3.155028856836414e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
case 20: {
constexpr size_t nb_points = 552;
SmallArray<R3> point_list(nb_points);
SmallArray<double> weight_list(nb_points);
std::array descriptor_list = //
{Descriptor{2, 5.418454790084648e-03, {2.967759596934131e-01}},
Descriptor{2, 3.820897988248627e-03, {1.209047972112185e-01}},
Descriptor{2, 4.057458152334048e-03, {3.177959071881044e-01}},
Descriptor{2, 4.147670297750325e-03, {2.012655712414790e-01}},
Descriptor{2, 5.289566609934361e-03, {1.678838969272885e-01}},
Descriptor{2, 9.720418198623532e-04, {3.621493960968947e-02}},
Descriptor{3, 2.988176136780452e-03, {5.260244961748377e-02}},
Descriptor{3, 7.061746923528361e-03, {3.045785563313042e-01}},
Descriptor{4, 1.138014164865969e-03, {3.228230549839516e-02, 8.181532733687802e-01}},
Descriptor{4, 3.284328089439585e-04, {8.126514470519638e-03, 1.671963931828212e-01}},
Descriptor{4, 4.517305074533165e-03, {1.851459522994347e-01, 6.611011876662430e-02}},
Descriptor{4, 2.743957098139693e-03, {4.110775382017770e-01, 1.281831845252744e-01}},
Descriptor{4, 5.345104029866354e-04, {1.005979740685446e-02, 5.566366248307155e-01}},
Descriptor{4, 8.527602773365834e-04, {8.230161503723588e-02, 8.242515811428504e-01}},
Descriptor{4, 1.608673320950611e-03, {3.801282860266467e-02, 6.072922714391159e-01}},
Descriptor{4, 2.164021789623034e-03, {8.297816905794758e-02, 1.927591204214162e-01}},
Descriptor{4, 1.298964551990821e-03, {3.232830149045374e-02, 2.290899793113822e-01}},
Descriptor{4, 7.540221084980848e-04, {1.406521940177762e-01, 4.062459178585371e-03}},
Descriptor{4, 3.936392177197076e-03, {1.139719439112915e-01, 5.168656572693773e-01}},
Descriptor{4, 8.260437254311268e-05, {7.453571377174895e-03, 2.517856316811188e-02}},
Descriptor{4, 2.202593581265821e-03, {1.110171267302689e-01, 3.907070674791312e-01}},
Descriptor{5, 1.142912288312416e-03, {5.313810503913767e-02, 5.333767142737392e-01, 9.768492667580009e-03}},
Descriptor{5, 8.037341179884985e-04, {9.439207428728114e-02, 9.450517146275739e-02, 7.609480923624367e-01}},
Descriptor{5, 6.441055085633393e-04, {5.505445164272958e-02, 7.653955692270024e-01, 5.660747947619223e-03}},
Descriptor{5, 2.284803061568028e-03, {1.798637301234305e-01, 9.751720382220438e-02, 3.466187077541209e-02}},
Descriptor{5, 1.768215173403588e-03, {2.121920547752147e-01, 4.095036586170944e-01, 4.613078410418590e-02}},
Descriptor{5, 1.364093116604035e-03, {1.290161512351960e-01, 4.765557207500070e-01, 9.956030373782836e-03}},
Descriptor{5, 1.409513020242023e-03, {1.614873223066114e-01, 1.376084748677020e-02, 2.264813194055542e-01}},
Descriptor{5, 5.352196172820926e-03, {1.059283078939860e-01, 4.143500741402470e-01, 1.944202417194029e-01}},
Descriptor{5, 2.357251753798956e-03, {2.046229328456809e-01, 2.864083155254953e-01, 3.607794123452725e-02}},
Descriptor{5, 2.335500281519085e-04, {7.441796869877018e-02, 2.361583233015298e-02, 8.995240292632410e-01}},
Descriptor{5, 8.299191110448388e-04, {2.938352359686784e-01, 5.078745759286403e-01, 4.379772363790332e-03}},
Descriptor{5, 3.480327275620159e-04, {2.899004919931303e-01, 2.388614940511808e-03, 2.095834844884252e-02}},
Descriptor{5, 1.081306497459309e-03, {6.920395527608953e-03, 2.780090233488638e-01, 8.666224435610116e-02}},
Descriptor{5, 3.363592992643566e-03, {1.053191068972152e-01, 5.431130574905816e-01, 4.625008859127536e-02}},
Descriptor{5, 1.138819523953005e-03, {3.387615700292962e-01, 8.792325219258773e-03, 4.002505388571689e-01}}};
fill_quadrature_points(descriptor_list, point_list, weight_list);
m_point_list = point_list;
m_weight_list = weight_list;
break;
}
default: {
throw NormalError("Gauss quadrature formulae handle degrees up to 20 on tetrahedra");
}
}
}
src/analysis/SimplicialGaussQuadrature.hpp deleted 100644 → 0
+ 0
− 35
View file @ 58b1d75e
#ifndef SIMPLICIAL_GAUSS_QUADRATURE_HPP
#define SIMPLICIAL_GAUSS_QUADRATURE_HPP
#include <analysis/QuadratureFormula.hpp>
/**
* Defines Gauss quadrature on the reference simplex element
* - in 1d, the segment \f$]-1,1[\f$
* - in 2d, the triangle defined by \f$(-1,-1)\f$, \f$(1,-1)\f$ and \f$(-1,1)\f$
* - in 3d, the tetrahedron joining \f$(-1,-1-1)\f$, \f$(1,-1,-1)\f$, \f$(-1,1,-1)\f$ and \f$(-1,1-,1)\f$
*
* \note for triangles, formulae are extracted from Dunavant (https://doi.org/10.1002/nme.1620210612)
*
* \note for tetrahedra, formulae are extracted from Jaśkowiec & Sukumar (https://doi.org/10.1002/nme.6313)
*/
template <size_t Dimension>
class SimplicialGaussQuadrature final : public QuadratureForumla<Dimension>
{
private:
void _buildPointAndWeightLists();
public:
SimplicialGaussQuadrature(SimplicialGaussQuadrature&&) = default;
SimplicialGaussQuadrature(const SimplicialGaussQuadrature&) = default;
explicit SimplicialGaussQuadrature(const size_t degree) : QuadratureForumla<Dimension>(degree)
{
this->_buildPointAndWeightLists();
}
SimplicialGaussQuadrature() = delete;
~SimplicialGaussQuadrature() = default;
};
#endif // SIMPLICIAL_GAUSS_QUADRATURE_HPP
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment