https://mooseframework.inl.gov
Loading...
Searching...
No Matches
RayTracingAngularQuadratureTest.C
Go to the documentation of this file.
1//* This file is part of the MOOSE framework
2//* https://mooseframework.inl.gov
3//*
4//* All rights reserved, see COPYRIGHT for full restrictions
5//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6//*
7//* Licensed under LGPL 2.1, please see LICENSE for details
8//* https://www.gnu.org/licenses/lgpl-2.1.html
9
10#include "gtest/gtest.h"
11
12#include "RayTracingAngularQuadrature.h"
13
14TEST(RayTracingAngularQuadratureTest, gaussLegendre)
15{
16 const std::vector<Real> x = {
17 3.5964357465057e-05, 0.0001894843595316997, 0.0004656390634237284, 0.0008644220255445423,
18 0.001385742858309946, 0.002029475369494216, 0.002795462117149317, 0.003683515291404982,
19 0.004693416984663079, 0.005824919319619315, 0.007077744539106756, 0.00845158508695204,
20 0.009946103689537855, 0.01156093344171705, 0.01329567789858499, 0.01514991117378167,
21 0.01712317804462782, 0.01921499406424482, 0.02142484568071723, 0.02375219036332271,
22 0.02619645673582899, 0.0287570447168386, 0.03143332566716089, 0.03422464254418162,
23 0.03713031006319617, 0.0401496148656687, 0.04328181569437978, 0.04652614357542062,
24 0.0498818020069885, 0.05334796715493673, 0.05692378805503834, 0.06060838682190589,
25 0.06440085886451835, 0.06830027310830861, 0.07230567222374851, 0.07641607286138052,
26 0.08063046589323758, 0.08494781666059065, 0.08936706522796428, 0.09388712664335841,
27 0.09850689120461087, 0.1032252247318361, 0.1080409688458743, 0.112952941252679,
28 0.1179599360335803, 0.1230607239413433, 0.1282540527019565, 0.1335386473220729,
29 0.1389132104020281, 0.1443764224543611, 0.1499269422277551, 0.1555634070363229,
30 0.161284433094157, 0.1670886158550527, 0.1729745303573371, 0.1789407315737048,
31 0.1849857547659781, 0.191108115844712, 0.1973063117335476, 0.2035788207382228,
32 0.2099241029201608, 0.2163406004745332, 0.2228267381127095, 0.2293809234490013,
33 0.236001547391602, 0.2426869845376282, 0.2494355935721665, 0.2562457176712257,
34 0.2631156849084962, 0.2700438086658234, 0.2770283880472709, 0.2840677082967137,
35 0.2911600412188127, 0.2983036456032996, 0.3054967676524565, 0.3127376414116798,
36 0.3200244892030347, 0.3273555220616868, 0.3347289401751018, 0.3421429333249114,
37 0.3495956813313329, 0.3570853545000323, 0.3646101140713286, 0.3721681126716179,
38 0.3797574947669143, 0.3873763971183971, 0.3950229492398449, 0.4026952738568517,
39 0.4103914873677097, 0.4181097003058446, 0.4258480178036894, 0.4336045400578885,
40 0.4413773627957088, 0.4491645777425507, 0.456964273090442, 0.4647745339673951,
41 0.4725934429075237, 0.4804190803217888, 0.4882495249692711, 0.4960828544288466,
42 0.5039171455711532, 0.5117504750307287, 0.5195809196782111, 0.527406557092476,
43 0.5352254660326043, 0.5430357269095578, 0.5508354222574486, 0.5586226372042911,
44 0.5663954599421114, 0.5741519821963106, 0.5818902996941556, 0.5896085126322897,
45 0.5973047261431478, 0.6049770507601547, 0.6126236028816023, 0.6202425052330853,
46 0.6278318873283821, 0.6353898859286713, 0.6429146454999678, 0.6504043186686675,
47 0.6578570666750887, 0.6652710598248982, 0.6726444779383132, 0.6799755107969651,
48 0.6872623585883204, 0.6945032323475433, 0.7016963543966999, 0.7088399587811873,
49 0.7159322917032862, 0.722971611952729, 0.7299561913341768, 0.736884315091503,
50 0.7437542823287744, 0.7505644064278338, 0.7573130154623722, 0.763998452608398,
51 0.7706190765509988, 0.7771732618872906, 0.7836593995254668, 0.7900758970798389,
52 0.7964211792617771, 0.8026936882664526, 0.8088918841552878, 0.8150142452340222,
53 0.8210592684262956, 0.8270254696426628, 0.8329113841449474, 0.8387155669058433,
54 0.8444365929636768, 0.8500730577722451, 0.8556235775456391, 0.8610867895979719,
55 0.8664613526779275, 0.8717459472980437, 0.8769392760586565, 0.8820400639664195,
56 0.8870470587473209, 0.8919590311541259, 0.8967747752681641, 0.9014931087953891,
57 0.9061128733566418, 0.9106329347720359, 0.9150521833394096, 0.9193695341067627,
58 0.9235839271386197, 0.9276943277762518, 0.9316997268916918, 0.9355991411354818,
59 0.9393916131780942, 0.9430762119449614, 0.9466520328450634, 0.9501181979930117,
60 0.9534738564245794, 0.9567181843056207, 0.9598503851343319, 0.9628696899368041,
61 0.9657753574558186, 0.9685666743328395, 0.9712429552831616, 0.9738035432641712,
62 0.9762478096366776, 0.9785751543192833, 0.9807850059357555, 0.9828768219553724,
63 0.9848500888262188, 0.9867043221014156, 0.9884390665582832, 0.9900538963104621,
64 0.991548414913048, 0.9929222554608932, 0.9941750806803806, 0.9953065830153369,
65 0.9963164847085949, 0.9972045378828509, 0.9979705246305057, 0.9986142571416898,
66 0.9991355779744554, 0.9995343609365761, 0.9998105156404682, 0.9999640356425352};
67 const std::vector<Real> w = {
68 9.229504873584985e-05, 0.0002148233152253478, 0.000337480317239408, 0.0004600702296712821,
69 0.0005825503573777825, 0.0007048884137269863, 0.0008270537761566921, 0.0009490162524693522,
70 0.001070745819720108, 0.001192212556002391, 0.001313386622258159, 0.001434238259734318,
71 0.001554737793051476, 0.001674855635517603, 0.00179456229540629, 0.001913828382672534,
72 0.00203262461588739, 0.002150921829256565, 0.002268690979679756, 0.002385903153820268,
73 0.002502529575169602, 0.002618541611078469, 0.002733910779775182, 0.002848608757344535,
74 0.002962607384675787, 0.003075878674365886, 0.003188394817591402, 0.003300128190930785,
75 0.003411051363141983, 0.003521137101900877, 0.003630358380479411, 0.003738688384383568,
76 0.003846100517936835, 0.003952568410805129, 0.004058065924474594, 0.004162567158665574,
77 0.004266046457693802, 0.00436847841676277, 0.004469837888211146, 0.004570099987675964,
78 0.00466924010020744, 0.004767233886309951, 0.004864057287920066, 0.004959686534309662,
79 0.005054098147923814, 0.005147268950142769, 0.005239176066975266, 0.005329796934670928,
80 0.005419109305263319, 0.005507091252028186, 0.005593721174869141, 0.005678977805620078,
81 0.005762840213266269, 0.005845287809082791, 0.005926300351689566, 0.006005857952021953,
82 0.006083941078211342, 0.006160530560380212, 0.006235607595353423, 0.006309153751267087,
83 0.006381150972096681, 0.006451581582095985, 0.006520428290126014, 0.006587674193905699,
84 0.006653302784164315, 0.006717297948686756, 0.00677964397627807, 0.006840325560614128,
85 0.006899327804001443, 0.006956636221035364, 0.00701223674215604, 0.007066115717101092,
86 0.007118259918260463, 0.007168656543918306, 0.007217293221401462, 0.007264158010114936,
87 0.007309239404469535, 0.00735252633671367, 0.007394008179647118, 0.007433674749227226,
88 0.007471516307073039, 0.007507523562855361, 0.007541687676577837, 0.007574000260744188,
89 0.007604453382421627, 0.007633039565186618, 0.007659751790959058, 0.007684583501728193,
90 0.007707528601160204, 0.007728581456094411, 0.007747736897929327, 0.007764990223888356,
91 0.007780337198176993, 0.00779377405302219, 0.007805297489593164, 0.007814904678819009,
92 0.007822593262076506, 0.007828361351771701, 0.007832207531805377, 0.007834130857915999,
93 0.007834130857916009, 0.007832207531805585, 0.007828361351772405, 0.007822593262076492,
94 0.007814904678820022, 0.007805297489593507, 0.007793774053022181, 0.007780337198177696,
95 0.007764990223888181, 0.007747736897929041, 0.00772858145609449, 0.007707528601160051,
96 0.007684583501727869, 0.007659751790959727, 0.007633039565186349, 0.007604453382421762,
97 0.007574000260743724, 0.00754168767657653, 0.007507523562855794, 0.007471516307072428,
98 0.007433674749227071, 0.007394008179647186, 0.007352526336714298, 0.007309239404469582,
99 0.0072641580101141, 0.007217293221402119, 0.007168656543918532, 0.007118259918260358,
100 0.00706611571710125, 0.0070122367421562, 0.00695663622103568, 0.006899327804001667,
101 0.006840325560614126, 0.006779643976277895, 0.006717297948686965, 0.006653302784164128,
102 0.00658767419390586, 0.006520428290125645, 0.006451581582096186, 0.006381150972096921,
103 0.0063091537512662, 0.00623560759535319, 0.006160530560380712, 0.006083941078211205,
104 0.006005857952022147, 0.005926300351689471, 0.005845287809082382, 0.00576284021326656,
105 0.00567897780562006, 0.005593721174868762, 0.005507091252028263, 0.005419109305263074,
106 0.005329796934671047, 0.00523917606697564, 0.00514726895014325, 0.00505409814792369,
107 0.004959686534309095, 0.004864057287920338, 0.004767233886310146, 0.00466924010020757,
108 0.00457009998767569, 0.004469837888211489, 0.004368478416763171, 0.004266046457692925,
109 0.004162567158665393, 0.004058065924474268, 0.003952568410804706, 0.003846100517936504,
110 0.003738688384383724, 0.00363035838047838, 0.003521137101901117, 0.003411051363142785,
111 0.003300128190930307, 0.003188394817591546, 0.003075878674366077, 0.002962607384675911,
112 0.002848608757344138, 0.002733910779775525, 0.002618541611078311, 0.002502529575169577,
113 0.002385903153820551, 0.002268690979679305, 0.00215092182925634, 0.002032624615887844,
114 0.001913828382672675, 0.001794562295405616, 0.001674855635518267, 0.001554737793051348,
115 0.001434238259734413, 0.001313386622258311, 0.001192212556002759, 0.001070745819719768,
116 0.0009490162524696159, 0.0008270537761568535, 0.0007048884137273808, 0.0005825503573776667,
117 0.0004600702296706742, 0.0003374803172395162, 0.0002148233152254676, 9.229504873548172e-05};
118
119 std::vector<Real> x_compare;
120 std::vector<Real> w_compare;
121 RayTracingAngularQuadrature::gaussLegendre(200, x_compare, w_compare);
122
123 EXPECT_EQ(x.size(), x_compare.size());
124 EXPECT_EQ(w.size(), w_compare.size());
125 for (std::size_t i = 0; i < x_compare.size(); ++i)
126 {
127 EXPECT_NEAR(x[i], x_compare[i], 1.e-10);
128 EXPECT_NEAR(w[i], w_compare[i], 1.e-10);
129 }
130}
131
132TEST(RayTracingAngularQuadratureTest, Chebyshev)
133{
134 const std::vector<Real> x = {
135 0.000000000000e+00, 6.283185307180e-02, 1.256637061436e-01, 1.884955592154e-01,
136 2.513274122872e-01, 3.141592653590e-01, 3.769911184308e-01, 4.398229715026e-01,
137 5.026548245744e-01, 5.654866776462e-01, 6.283185307180e-01, 6.911503837898e-01,
138 7.539822368616e-01, 8.168140899333e-01, 8.796459430051e-01, 9.424777960769e-01,
139 1.005309649149e+00, 1.068141502221e+00, 1.130973355292e+00, 1.193805208364e+00,
140 1.256637061436e+00, 1.319468914508e+00, 1.382300767580e+00, 1.445132620651e+00,
141 1.507964473723e+00, 1.570796326795e+00, 1.633628179867e+00, 1.696460032938e+00,
142 1.759291886010e+00, 1.822123739082e+00, 1.884955592154e+00, 1.947787445226e+00,
143 2.010619298297e+00, 2.073451151369e+00, 2.136283004441e+00, 2.199114857513e+00,
144 2.261946710585e+00, 2.324778563656e+00, 2.387610416728e+00, 2.450442269800e+00,
145 2.513274122872e+00, 2.576105975944e+00, 2.638937829015e+00, 2.701769682087e+00,
146 2.764601535159e+00, 2.827433388231e+00, 2.890265241303e+00, 2.953097094374e+00,
147 3.015928947446e+00, 3.078760800518e+00, 3.141592653590e+00, 3.204424506662e+00,
148 3.267256359733e+00, 3.330088212805e+00, 3.392920065877e+00, 3.455751918949e+00,
149 3.518583772021e+00, 3.581415625092e+00, 3.644247478164e+00, 3.707079331236e+00,
150 3.769911184308e+00, 3.832743037380e+00, 3.895574890451e+00, 3.958406743523e+00,
151 4.021238596595e+00, 4.084070449667e+00, 4.146902302739e+00, 4.209734155810e+00,
152 4.272566008882e+00, 4.335397861954e+00, 4.398229715026e+00, 4.461061568098e+00,
153 4.523893421169e+00, 4.586725274241e+00, 4.649557127313e+00, 4.712388980385e+00,
154 4.775220833456e+00, 4.838052686528e+00, 4.900884539600e+00, 4.963716392672e+00,
155 5.026548245744e+00, 5.089380098815e+00, 5.152211951887e+00, 5.215043804959e+00,
156 5.277875658031e+00, 5.340707511103e+00, 5.403539364174e+00, 5.466371217246e+00,
157 5.529203070318e+00, 5.592034923390e+00, 5.654866776462e+00, 5.717698629533e+00,
158 5.780530482605e+00, 5.843362335677e+00, 5.906194188749e+00, 5.969026041821e+00,
159 6.031857894892e+00, 6.094689747964e+00, 6.157521601036e+00, 6.220353454108e+00};
160
161 std::vector<Real> x_compare;
162 std::vector<Real> w_compare;
163 RayTracingAngularQuadrature::chebyshev(100, x_compare, w_compare);
164
165 EXPECT_EQ(x.size(), x_compare.size());
166 EXPECT_EQ(x.size(), w_compare.size());
167 for (std::size_t i = 0; i < x_compare.size(); ++i)
168 {
169 EXPECT_NEAR(x[i], x_compare[i], 1.e-10);
170 EXPECT_NEAR(6.283185307180e-02, w_compare[i], 1.e-10);
171 }
172}
173
174TEST(RayTracingAngularQuadratureTest, BasicGetters)
175{
176 const unsigned int polar_order = 3;
177 const unsigned int azimuthal_order = 3;
178 const Real mu_min = -1;
179 const Real mu_max = 1;
180 RayTracingAngularQuadrature aq(3, polar_order, azimuthal_order, mu_min, mu_max);
181
182 EXPECT_EQ(polar_order, aq.polarOrder());
183 EXPECT_EQ(azimuthal_order, aq.azimuthalOrder());
184 EXPECT_EQ(mu_min, aq.muMin());
185 EXPECT_EQ(mu_max, aq.muMax());
186 EXPECT_EQ((std::size_t)9, aq.numDirections());
187
188 const Point rotation(1, 0, 0);
189 aq.rotate(rotation);
190 for (unsigned int d = 0; d < 3; ++d)
191 EXPECT_NEAR(rotation(d), aq.currentRotationDirection()(d), 1.e-10);
192
193 for (unsigned int i = 0; i < aq.numDirections(); ++i)
194 EXPECT_TRUE(aq.hasDirection(i));
195}
196
197void
198testWeights(const std::vector<std::vector<Real>> & weights, const RayTracingAngularQuadrature & aq)
199{
200 EXPECT_EQ(weights.size(), aq.numDirections());
201 for (unsigned int l = 0; l < aq.numDirections(); ++l)
202 {
203 EXPECT_EQ(weights[l].size(), aq.getWeights(l).size());
204 for (std::size_t i = 0; i < weights[l].size(); ++i)
205 EXPECT_NEAR(aq.getWeights(l)[i], weights[l][i], 1.e-10);
206 }
207}
208
209void
210testPolarSins2D(const std::vector<std::vector<Real>> & polar_sins,
211 const RayTracingAngularQuadrature & aq)
212{
213 EXPECT_EQ(aq.dim(), (unsigned int)2);
214 EXPECT_EQ(polar_sins.size(), aq.numDirections());
215 for (unsigned int l = 0; l < aq.numDirections(); ++l)
216 {
217 EXPECT_EQ(polar_sins[l].size(), aq.numPolar(l));
218 for (std::size_t i = 0; i < polar_sins[l].size(); ++i)
219 EXPECT_NEAR(aq.getPolarSins(l)[i], polar_sins[l][i], 1.e-10);
220 }
221}
222
223void
224testDirections(const std::vector<Point> & directions, const RayTracingAngularQuadrature & aq)
225{
226 EXPECT_EQ(directions.size(), aq.numDirections());
227 for (unsigned int l = 0; l < aq.numDirections(); ++l)
228 for (unsigned int d = 0; d < 3; ++d)
229 EXPECT_NEAR(aq.getDirection(l)(d), directions[l](d), 1.e-10);
230}
231
232TEST(RayTracingAngularQuadratureTest, HalfRange2D)
233{
234 RayTracingAngularQuadrature aq(2, 3, 3, 0, 1);
235 EXPECT_EQ((std::size_t)3, aq.numDirections());
236
237 const std::vector<std::vector<Real>> weights = {{9.308422677303e-01, 1.163552834663e+00},
238 {9.308422677303e-01, 1.163552834663e+00},
239 {9.308422677303e-01, 1.163552834663e+00}};
240 const std::vector<std::vector<Real>> polar_sins = {{8.660254037844e-01, 4.611959078084e-01},
241 {8.660254037844e-01, 4.611959078084e-01},
242 {8.660254037844e-01, 4.611959078084e-01}};
243 const std::vector<Point> directions = {
244 {1.000000000000e+00, 0.000000000000e+00, 0.000000000000e+00},
245 {-5.000000000000e-01, 8.660254037844e-01, 0.000000000000e+00},
246 {-5.000000000000e-01, -8.660254037844e-01, 0.000000000000e+00}};
247
248 testWeights(weights, aq);
249 testPolarSins2D(polar_sins, aq);
250 testDirections(directions, aq);
251
252 aq.rotate(Point(1, 1, 0));
253
254 const std::vector<std::vector<Real>> rot_weights = {{9.308422677303e-01, 1.163552834663e+00},
255 {9.308422677303e-01},
256 {1.163552834663e+00},
257 {9.308422677303e-01},
258 {1.163552834663e+00}};
259 const std::vector<std::vector<Real>> rot_polar_sins = {{8.660254037844e-01, 4.611959078084e-01},
260 {8.660254037844e-01},
261 {4.611959078084e-01},
262 {8.660254037844e-01},
263 {4.611959078084e-01}};
264 const std::vector<Point> rot_directions = {
265 {7.071067811865e-01, 7.071067811865e-01, 0.000000000000e+00},
266 {9.805806756909e-01, -1.961161351382e-01, 0.000000000000e+00},
267 {9.350384426221e-01, 3.545463450930e-01, 0.000000000000e+00},
268 {-1.961161351382e-01, 9.805806756909e-01, 0.000000000000e+00},
269 {3.545463450930e-01, 9.350384426221e-01, 0.000000000000e+00}};
270
271 testWeights(rot_weights, aq);
272 testPolarSins2D(rot_polar_sins, aq);
273 testDirections(rot_directions, aq);
274}
275
276TEST(RayTracingAngularQuadratureTest, FullRange2D)
277{
278 RayTracingAngularQuadrature aq(2, 3, 4, -1, 1);
279
280 const std::vector<std::vector<Real>> weights = {{6.981317007977e-01, 8.726646259972e-01},
281 {6.981317007977e-01, 8.726646259972e-01},
282 {6.981317007977e-01, 8.726646259972e-01},
283 {6.981317007977e-01, 8.726646259972e-01}};
284 const std::vector<std::vector<Real>> polar_sins = {{1.000000000000e+00, 6.324555320337e-01},
285 {1.000000000000e+00, 6.324555320337e-01},
286 {1.000000000000e+00, 6.324555320337e-01},
287 {1.000000000000e+00, 6.324555320337e-01}};
288 const std::vector<Point> directions = {
289 {1.000000000000e+00, 0.000000000000e+00, 0.000000000000e+00},
290 {6.123233995737e-17, 1.000000000000e+00, 0.000000000000e+00},
291 {-1.000000000000e+00, 1.224646799147e-16, 0.000000000000e+00},
292 {-1.836970198721e-16, -1.000000000000e+00, 0.000000000000e+00}};
293
294 testWeights(weights, aq);
295 testPolarSins2D(polar_sins, aq);
296 testDirections(directions, aq);
297}
298
299TEST(RayTracingAngularQuadratureTest, Cone2D)
300{
301 RayTracingAngularQuadrature aq(2, 4, 3, 0.8, 1);
302
303 const std::vector<std::vector<Real>> weights = {{1.365849618394e+00, 7.285454839996e-01},
304 {1.365849618394e+00, 7.285454839996e-01},
305 {1.365849618394e+00, 7.285454839996e-01}};
306 const std::vector<std::vector<Real>> polar_sins = {{3.572779604940e-01, 1.660719917434e-01},
307 {3.572779604940e-01, 1.660719917434e-01},
308 {3.572779604940e-01, 1.660719917434e-01}};
309 const std::vector<Point> directions = {
310 {1.000000000000e+00, 0.000000000000e+00, 0.000000000000e+00},
311 {-5.000000000000e-01, 8.660254037844e-01, 0.000000000000e+00},
312 {-5.000000000000e-01, -8.660254037844e-01, 0.000000000000e+00}};
313
314 testWeights(weights, aq);
315 testPolarSins2D(polar_sins, aq);
316 testDirections(directions, aq);
317
318 aq.rotate(Point(1, 2, 0));
319
320 const std::vector<std::vector<Real>> rot_weights = {{1.365849618394e+00, 7.285454839996e-01},
321 {1.365849618394e+00},
322 {7.285454839996e-01},
323 {1.365849618394e+00},
324 {7.285454839996e-01}};
325 const std::vector<std::vector<Real>> rot_polar_sins = {{3.572779604940e-01, 1.660719917434e-01},
326 {3.572779604940e-01},
327 {1.660719917434e-01},
328 {3.572779604940e-01},
329 {1.660719917434e-01}};
330 const std::vector<Point> rot_directions = {
331 {4.472135955000e-01, 8.944271909999e-01, 0.000000000000e+00},
332 {7.057959156146e-01, 7.084152211110e-01, 0.000000000000e+00},
333 {5.716162833142e-01, 8.205210689861e-01, 0.000000000000e+00},
334 {1.432546275200e-01, 9.896858651583e-01, 0.000000000000e+00},
335 {3.134470852004e-01, 9.496056680430e-01, 0.000000000000e+00}};
336
337 testWeights(rot_weights, aq);
338 testPolarSins2D(rot_polar_sins, aq);
339 testDirections(rot_directions, aq);
340}
341
342TEST(RayTracingAngularQuadratureTest, HalfRange3D)
343{
344 RayTracingAngularQuadrature aq(3, 3, 5, 0, 1);
345
346 const std::vector<std::vector<Real>> weights = {{3.490658503989e-01},
347 {5.585053606382e-01},
348 {3.490658503989e-01},
349 {3.490658503989e-01},
350 {5.585053606382e-01},
351 {3.490658503989e-01},
352 {3.490658503989e-01},
353 {5.585053606382e-01},
354 {3.490658503989e-01},
355 {3.490658503989e-01},
356 {5.585053606382e-01},
357 {3.490658503989e-01},
358 {3.490658503989e-01},
359 {5.585053606382e-01},
360 {3.490658503989e-01}};
361 const std::vector<Point> directions = {
362 {9.936288716723e-01, 0.000000000000e+00, 1.127016653793e-01},
363 {8.660254037844e-01, 0.000000000000e+00, 5.000000000000e-01},
364 {4.611959078084e-01, 0.000000000000e+00, 8.872983346207e-01},
365 {3.070482074483e-01, 9.449972131829e-01, 1.127016653793e-01},
366 {2.676165673298e-01, 8.236391035463e-01, 5.000000000000e-01},
367 {1.425173732490e-01, 4.386233734099e-01, 8.872983346207e-01},
368 {-8.038626432845e-01, 5.840403970210e-01, 1.127016653793e-01},
369 {-7.006292692220e-01, 5.090369604551e-01, 5.000000000000e-01},
370 {-3.731153271532e-01, 2.710841530274e-01, 8.872983346207e-01},
371 {-8.038626432845e-01, -5.840403970210e-01, 1.127016653793e-01},
372 {-7.006292692220e-01, -5.090369604551e-01, 5.000000000000e-01},
373 {-3.731153271532e-01, -2.710841530274e-01, 8.872983346207e-01},
374 {3.070482074483e-01, -9.449972131829e-01, 1.127016653793e-01},
375 {2.676165673298e-01, -8.236391035463e-01, 5.000000000000e-01},
376 {1.425173732490e-01, -4.386233734099e-01, 8.872983346207e-01}};
377
378 testWeights(weights, aq);
379 testDirections(directions, aq);
380
381 aq.rotate(Point(1, 2, 3));
382
383 const std::vector<Point> rot_directions = {
384 {-8.586078935314e-01, 5.046059144028e-01, 9.036236116458e-02},
385 {-6.409660482853e-01, 6.545595765332e-01, 4.008918628686e-01},
386 {-1.753657054642e-01, 6.805339898760e-01, 7.114213645727e-01},
387 {-5.833577901160e-01, -4.801349160080e-01, 6.551062136333e-01},
388 {-4.010640197232e-01, -2.037192029917e-01, 8.931103730312e-01},
389 {-4.760752035289e-02, 2.234634938537e-01, 9.735489668838e-01},
390 {5.396988555796e-01, -7.180938037975e-01, 4.393932569278e-01},
391 {5.777678286554e-01, -4.111190156956e-01, 7.050996320409e-01},
392 {4.736626882716e-01, 1.130141415814e-01, 8.734251321905e-01},
393 {9.585359304955e-01, 1.195803460343e-01, -2.586685345987e-01},
394 {9.428171516622e-01, 3.189796303179e-01, 9.668409369634e-02},
395 {6.680672094129e-01, 5.018231838641e-01, 5.494175969549e-01},
396 {9.433483284653e-02, 8.752503299170e-01, -4.743814913042e-01},
397 {1.895981924719e-01, 9.776052213984e-01, -9.132664729392e-02},
398 {2.669456024205e-01, 8.525697394004e-01, 4.492937622616e-01}};
399
400 testWeights(weights, aq);
401 testDirections(rot_directions, aq);
402}
403
404TEST(RayTracingAngularQuadratureTest, FullRange3D)
405{
406 RayTracingAngularQuadrature aq(3, 3, 3, -1, 1);
407
408 const std::vector<std::vector<Real>> weights = {{5.817764173314e-01},
409 {9.308422677303e-01},
410 {5.817764173314e-01},
411 {5.817764173314e-01},
412 {9.308422677303e-01},
413 {5.817764173314e-01},
414 {5.817764173314e-01},
415 {9.308422677303e-01},
416 {5.817764173314e-01}};
417 const std::vector<Point> directions = {
418 {6.324555320337e-01, 0.000000000000e+00, -7.745966692415e-01},
419 {1.000000000000e+00, 0.000000000000e+00, 0.000000000000e+00},
420 {6.324555320337e-01, 0.000000000000e+00, 7.745966692415e-01},
421 {-3.162277660168e-01, 5.477225575052e-01, -7.745966692415e-01},
422 {-5.000000000000e-01, 8.660254037844e-01, 0.000000000000e+00},
423 {-3.162277660168e-01, 5.477225575052e-01, 7.745966692415e-01},
424 {-3.162277660168e-01, -5.477225575052e-01, -7.745966692415e-01},
425 {-5.000000000000e-01, -8.660254037844e-01, 0.000000000000e+00},
426 {-3.162277660168e-01, -5.477225575052e-01, 7.745966692415e-01}};
427
428 testWeights(weights, aq);
429 testDirections(directions, aq);
430}
431
432TEST(RayTracingAngularQuadratureTest, Cone3D)
433{
434 RayTracingAngularQuadrature aq(3, 4, 5, 0.75, 1);
435
436 const std::vector<std::vector<Real>> weights = {
437 {2.185636451999e-01}, {4.097548855181e-01}, {4.097548855181e-01}, {2.185636451999e-01},
438 {2.185636451999e-01}, {4.097548855181e-01}, {4.097548855181e-01}, {2.185636451999e-01},
439 {2.185636451999e-01}, {4.097548855181e-01}, {4.097548855181e-01}, {2.185636451999e-01},
440 {2.185636451999e-01}, {4.097548855181e-01}, {4.097548855181e-01}, {2.185636451999e-01},
441 {2.185636451999e-01}, {4.097548855181e-01}, {4.097548855181e-01}, {2.185636451999e-01}};
442 std::vector<Point> directions = {{6.412189638587e-01, 0.000000000000e+00, 7.673579610507e-01},
443 {5.540214839611e-01, 0.000000000000e+00, 8.325023695519e-01},
444 {3.977412451860e-01, 0.000000000000e+00, 9.174976304481e-01},
445 {1.855117874682e-01, 0.000000000000e+00, 9.826420389493e-01},
446 {1.981475569478e-01, 6.098354739499e-01, 7.673579610507e-01},
447 {1.712020537928e-01, 5.269057424887e-01, 8.325023695519e-01},
448 {1.229088041263e-01, 3.782744030335e-01, 9.174976304481e-01},
449 {5.732629498455e-02, 1.764321943212e-01, 9.826420389493e-01},
450 {-5.187570388772e-01, 3.768990504464e-01, 7.673579610507e-01},
451 {-4.482127957734e-01, 3.256456577255e-01, 8.325023695519e-01},
452 {-3.217794267193e-01, 2.337864381488e-01, 9.174976304481e-01},
453 {-1.500821887186e-01, 1.090410928002e-01, 9.826420389493e-01},
454 {-5.187570388772e-01, -3.768990504464e-01, 7.673579610507e-01},
455 {-4.482127957734e-01, -3.256456577255e-01, 8.325023695519e-01},
456 {-3.217794267193e-01, -2.337864381488e-01, 9.174976304481e-01},
457 {-1.500821887186e-01, -1.090410928002e-01, 9.826420389493e-01},
458 {1.981475569478e-01, -6.098354739499e-01, 7.673579610507e-01},
459 {1.712020537928e-01, -5.269057424887e-01, 8.325023695519e-01},
460 {1.229088041263e-01, -3.782744030335e-01, 9.174976304481e-01},
461 {5.732629498455e-02, -1.764321943212e-01, 9.826420389493e-01}};
462
463 testWeights(weights, aq);
464 testDirections(directions, aq);
465
466 aq.rotate(Point(0, 1.1, 1.5));
467 const std::vector<Point> rot_directions = {
468 {6.412189638587e-01, 4.537876151607e-01, 6.188012934010e-01},
469 {5.540214839611e-01, 4.923116512368e-01, 6.713340698684e-01},
470 {3.977412451860e-01, 5.425747601114e-01, 7.398746728791e-01},
471 {1.855117874682e-01, 5.810987961874e-01, 7.924074493465e-01},
472 {1.981475569478e-01, 9.455619880039e-01, 2.581667533160e-01},
473 {1.712020537928e-01, 9.172110743248e-01, 3.597411596038e-01},
474 {1.229088041263e-01, 8.476171285219e-01, 5.161769360447e-01},
475 {5.732629498455e-02, 7.233745991178e-01, 6.880718605309e-01},
476 {-5.187570388772e-01, 7.577208923740e-01, 3.959168901112e-01},
477 {-4.482127957734e-01, 7.549139365054e-01, 4.787590606714e-01},
478 {-3.217794267193e-01, 7.311013117978e-01, 6.016218683090e-01},
479 {-1.500821887186e-01, 6.690300781751e-01, 7.279245092222e-01},
480 {-5.187570388772e-01, 1.498543379474e-01, 8.416856966907e-01},
481 {-4.482127957734e-01, 2.297093659682e-01, 8.639090790653e-01},
482 {-3.217794267193e-01, 3.540482084249e-01, 8.781274774492e-01},
483 {-1.500821887186e-01, 4.931675141998e-01, 8.568903894708e-01},
484 {1.981475569478e-01, -3.798675768249e-02, 9.794358334860e-01},
485 {1.712020537928e-01, 6.741222814882e-02, 9.829269801329e-01},
486 {1.229088041263e-01, 2.375323917008e-01, 9.635724097135e-01},
487 {5.732629498455e-02, 4.388229932570e-01, 8.967430381621e-01}};
488
489 testWeights(weights, aq);
490 testDirections(rot_directions, aq);
491}
x
const std::vector< double > x
Definition EquilibriumConstantFitTest.C:17
testWeights
void testWeights(const std::vector< std::vector< Real > > &weights, const RayTracingAngularQuadrature &aq)
Definition RayTracingAngularQuadratureTest.C:198
testDirections
void testDirections(const std::vector< Point > &directions, const RayTracingAngularQuadrature &aq)
Definition RayTracingAngularQuadratureTest.C:224
testPolarSins2D
void testPolarSins2D(const std::vector< std::vector< Real > > &polar_sins, const RayTracingAngularQuadrature &aq)
Definition RayTracingAngularQuadratureTest.C:210
TEST
TEST(RayTracingAngularQuadratureTest, gaussLegendre)
Definition RayTracingAngularQuadratureTest.C:14
RayTracingAngularQuadrature::muMax
Real muMax() const
Get the maximum mu.
Definition RayTracingAngularQuadrature.h:154
RayTracingAngularQuadrature::getWeights
const std::vector< Real > & getWeights(const unsigned int l) const
Get the weights associated with the direction l.
Definition RayTracingAngularQuadrature.C:210
RayTracingAngularQuadrature::currentRotationDirection
const libMesh::Point & currentRotationDirection() const
Get the current rotation direction.
Definition RayTracingAngularQuadrature.h:159
RayTracingAngularQuadrature::numPolar
std::size_t numPolar(const unsigned int l) const
The number of polar directions associated with the given direction.
Definition RayTracingAngularQuadrature.C:231
RayTracingAngularQuadrature::chebyshev
static void chebyshev(const unsigned int order, std::vector< Real > &x, std::vector< Real > &w)
Builds Chebyshev quadrature on [0, 2\pi] with weights that sum to 2\pi.
Definition RayTracingAngularQuadrature.C:247
RayTracingAngularQuadrature::polarOrder
unsigned int polarOrder() const
Get the polar order.
Definition RayTracingAngularQuadrature.h:142
RayTracingAngularQuadrature::azimuthalOrder
unsigned int azimuthalOrder() const
Get the azimuthal order.
Definition RayTracingAngularQuadrature.h:146
RayTracingAngularQuadrature::numDirections
std::size_t numDirections() const
Get the number of directions in the rotated and projected quadrature.
Definition RayTracingAngularQuadrature.h:117
RayTracingAngularQuadrature::gaussLegendre
static void gaussLegendre(const unsigned int order, std::vector< Real > &x, std::vector< Real > &w)
Builds Gauss-Legendre quadrature on [0, 1] (symmetric about 0.5), with weights that sum to 1.
Definition RayTracingAngularQuadrature.C:85
RayTracingAngularQuadrature::hasDirection
bool hasDirection(const unsigned int l) const
Whether or not the angular quadrature has direction l.
Definition RayTracingAngularQuadrature.h:121
RayTracingAngularQuadrature::getDirection
const libMesh::Point & getDirection(const unsigned int l) const
Get the direction associated with direction l.
Definition RayTracingAngularQuadrature.C:203
RayTracingAngularQuadrature::rotate
void rotate(const libMesh::Point &rotation_direction)
Rotates the quadrature to a given direction.
Definition RayTracingAngularQuadrature.C:129
RayTracingAngularQuadrature::getPolarSins
const std::vector< Real > & getPolarSins(const unsigned int l) const
Gets the polar sins for the direction l.
Definition RayTracingAngularQuadrature.C:224
RayTracingAngularQuadrature::dim
unsigned int dim() const
Get the quadrature dimension.
Definition RayTracingAngularQuadrature.h:164
RayTracingAngularQuadrature::muMin
Real muMin() const
Get the minimum mu.
Definition RayTracingAngularQuadrature.h:150
Generated on Fri Sep 11 2026 20:36:40 for https://mooseframework.inl.gov by doxygen 1.9.8