https://mooseframework.inl.gov
Loading...
Searching...
No Matches
TestStochasticToolsSobolCalculators.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#include <vector>
10
11#include "gtest/gtest.h"
12#include "SobolCalculators.h"
13#include "BootstrapCalculators.h"
14#include "StochasticToolsUtils.h"
15#include "MooseRandom.h"
16#include "libmesh/communicator.h"
17#include "libmesh/parallel_object.h"
18
19using namespace StochasticTools;
20
21Real
22g_function(const std::vector<Real> & q_vector, const DenseMatrix<Real> & data, std::size_t row)
23{
24 Real y = 1;
25 for (std::size_t c = 0; c < data.n(); ++c)
26 y *= (std::abs(4 * data(row, c) - 2) + q_vector[c]) / (1 + q_vector[c]);
27 return y;
28}
29
30void
31evaluate(const std::vector<Real> & q_vector,
32 const DenseMatrix<Real> & data,
33 std::vector<Real> & out)
34{
35 for (std::size_t i = 0; i < data.m(); ++i)
36 out.push_back(g_function(q_vector, data, i));
37}
38
39Real
40model_association_index(const std::vector<Real> & data, std::size_t count)
41{
42 return 1 - std::accumulate(data.begin(), data.begin() + count, 0.);
43}
44
45std::vector<std::vector<Real>>
46sobolidx(const std::vector<Real> & q_vector, std::size_t K, bool resample = true)
47{
48 MooseRandom generator;
49 generator.seed(0, 1980);
50 generator.seed(1, 1949);
51
52 const std::size_t n = q_vector.size();
53
54 DenseMatrix<Real> M1(K, n); // "sample" matrix
55 DenseMatrix<Real> M2(K, n); // "re-sample" matrix
56
57 for (std::size_t r = 0; r < K; ++r)
58 for (std::size_t c = 0; c < n; ++c)
59 {
60 M1(r, c) = generator.rand(0);
61 M2(r, c) = generator.rand(1);
62 }
63
64 std::vector<DenseMatrix<Real>> Ni(n, DenseMatrix<Real>(K, n));
65 std::vector<DenseMatrix<Real>> Nni(n, DenseMatrix<Real>(K, n));
66 for (std::size_t j = 0; j < n; ++j)
67 for (std::size_t r = 0; r < K; ++r)
68 for (std::size_t c = 0; c < n; ++c)
69 {
70 Ni[j](r, c) = j == c ? M1(r, c) : M2(r, c);
71 Nni[j](r, c) = j == c ? M2(r, c) : M1(r, c);
72 }
73
74 // Output data
75 std::vector<Real> data;
76
77 // a0
78 evaluate(q_vector, M2, data);
79
80 // ai
81 for (std::size_t i = 0; i < n; ++i)
82 evaluate(q_vector, Ni[i], data);
83
84 // ani
85 if (resample)
86 for (std::size_t i = 0; i < n; ++i)
87 evaluate(q_vector, Nni[i], data);
88
89 // aK
90 evaluate(q_vector, M1, data);
91
92 return reshapeVector(data, K, false);
93}
94
95TEST(StochasticTools, Sobol_Saltelli2002)
96{
97 // This tests the C++ against the results from the TestSobolCalculator.py script, these values
98 // also agree with what is reported by "Making best use of model evaluations to compute
99 // sensitivity indices;" Saltelli, 2002.
100 //
101 // These calculations are based on random number generation and agree well for non-zero terms, the
102 // absolute error is higher for the near-zero terms.
103 {
104 // Compute SOBOL vectors of g_function
105 std::vector<Real> q_vector = {0, 0.5, 3, 9, 99, 99};
106 std::vector<std::vector<Real>> data = sobolidx(q_vector, 100000);
107
108 // Compute SOBOL indices
109 Parallel::Communicator comm;
110 libMesh::ParallelObject po(comm);
111 SobolCalculator<std::vector<Real>, Real> calc(po, "SOBOL", true);
112 std::vector<Real> sobol = calc.compute(data, false);
113
114 // First-order
115 EXPECT_NEAR(sobol[0], 0.585817378, 1e-2); // S_1
116 EXPECT_NEAR(sobol[1], 0.261775886, 1e-2); // S_2
117 EXPECT_NEAR(sobol[2], 0.036806879, 1e-2); // S_3
118 EXPECT_NEAR(sobol[3], 0.005850546, 1e-2); // S_4
119 EXPECT_NEAR(sobol[4], 0.000059171, 1e-2); // S_5
120 EXPECT_NEAR(sobol[5], 0.000058227, 1e-2); // S_6
121
122 // Total-effect
123 EXPECT_NEAR(sobol[6], 0.686102012, 1e-2); // ST_1
124 EXPECT_NEAR(sobol[7], 0.349098045, 1e-2); // ST_2
125 EXPECT_NEAR(sobol[8], 0.044801021, 1e-2); // ST_3
126 EXPECT_NEAR(sobol[9], 0.002512902, 1e-2); // ST_4
127 EXPECT_NEAR(sobol[10], -0.007565606, 1e-2); // ST_5
128 EXPECT_NEAR(sobol[11], -0.007483272, 1e-2); // ST_6
129
130 // Second-order
131 EXPECT_NEAR(sobol[12], 0.081273974, 1e-2); // S_21;
132 EXPECT_NEAR(sobol[13], 0.006920649, 1e-2); // S_31;
133 EXPECT_NEAR(sobol[14], 0.006375308, 1e-1); // S_32;
134 EXPECT_NEAR(sobol[15], -0.004536444, 1e-1); // S_41;
135 EXPECT_NEAR(sobol[16], -0.001670717, 1e-2); // S_42;
136 EXPECT_NEAR(sobol[17], -0.000131402, 1e-2); // S_43;
137 EXPECT_NEAR(sobol[18], -0.006650540, 1e-2); // S_51;
138 EXPECT_NEAR(sobol[19], -0.001642939, 1e-2); // S_52;
139 EXPECT_NEAR(sobol[20], -0.000117414, 1e-2); // S_53;
140 EXPECT_NEAR(sobol[21], 0.000029383, 1e-2); // S_54;
141 EXPECT_NEAR(sobol[22], -0.006641290, 1e-2); // S_61;
142 EXPECT_NEAR(sobol[23], -0.001713718, 1e-2); // S_62;
143 EXPECT_NEAR(sobol[24], -0.000123219, 1e-2); // S_63;
144 EXPECT_NEAR(sobol[25], 0.000027036, 1e-2); // S_64;
145 EXPECT_NEAR(sobol[26], -0.000000386, 1e-2); // S_65;
146 }
147
148 // Perform bootstrapping of Sobol indices
149 {
150 // Construct Sobol calculator
151 Parallel::Communicator comm;
152 libMesh::ParallelObject po(comm);
153 SobolCalculator<std::vector<Real>, Real> calc(po, "SOBOL", true);
154
155 // Construct bootstrap calculator
156 MooseEnum boot("percentile", "percentile");
157 auto boot_calc = makeBootstrapCalculator(boot, po, {0.05, 0.95}, 10000, 1993, calc);
158
159 // Compute SOBOL vectors of g_function
160 std::vector<Real> q_vector = {0, 0.5, 3, 9, 99, 99};
161 std::vector<std::vector<Real>> data = sobolidx(q_vector, 1024);
162
163 // Compute mean sobol indices
164 const std::vector<Real> sobol = calc.compute(data, false);
165 // Compute confidence intervals
166 const std::vector<std::vector<Real>> sobol_ci = boot_calc->compute(data, false);
167
168 // S_1
169 EXPECT_NEAR(sobol[0], 0.595124392, 1e-2); // Mean
170 EXPECT_NEAR(sobol_ci[0][0], 0.518401934, 1e-2); // 5% CI
171 EXPECT_NEAR(sobol_ci[1][0], 0.694457878, 1e-2); // 95% CI
172 // S_2
173 EXPECT_NEAR(sobol[1], 0.251630423, 1e-2); // Mean
174 EXPECT_NEAR(sobol_ci[0][1], 0.212776416, 1e-2); // 5% CI
175 EXPECT_NEAR(sobol_ci[1][1], 0.302403418, 1e-2); // 95% CI
176 // S_3
177 EXPECT_NEAR(sobol[2], 0.033508970, 1e-2); // Mean
178 EXPECT_NEAR(sobol_ci[0][2], 0.028092482, 1e-2); // 5% CI
179 EXPECT_NEAR(sobol_ci[1][2], 0.040577359, 1e-2); // 95% CI
180 // S_4
181 EXPECT_NEAR(sobol[3], 0.005244906, 1e-2); // Mean
182 EXPECT_NEAR(sobol_ci[0][3], 0.004349295, 1e-2); // 5% CI
183 EXPECT_NEAR(sobol_ci[1][3], 0.006388217, 1e-2); // 95% CI
184 // S_5
185 EXPECT_NEAR(sobol[4], 0.000055256, 1e-2); // Mean
186 EXPECT_NEAR(sobol_ci[0][4], 0.000046050, 1e-2); // 5% CI
187 EXPECT_NEAR(sobol_ci[1][4], 0.000067359, 1e-2); // 95% CI
188 // S_6
189 EXPECT_NEAR(sobol[5], 0.000057292, 1e-2); // Mean
190 EXPECT_NEAR(sobol_ci[0][5], 0.000047778, 1e-2); // 5% CI
191 EXPECT_NEAR(sobol_ci[1][5], 0.000069655, 1e-2); // 95% CI
192
193 // ST_1
194 EXPECT_NEAR(sobol[6], 0.719603333, 1e-2); // Mean
195 EXPECT_NEAR(sobol_ci[0][6], 0.664919501, 1e-2); // 5% CI
196 EXPECT_NEAR(sobol_ci[1][6], 0.761403817, 1e-2); // 95% CI
197 // ST_2
198 EXPECT_NEAR(sobol[7], 0.391713495, 1e-1); // Mean
199 EXPECT_NEAR(sobol_ci[0][7], 0.284662598, 1e-1); // 5% CI
200 EXPECT_NEAR(sobol_ci[1][7], 0.472968290, 1e-1); // 95% CI
201 // ST_3
202 EXPECT_NEAR(sobol[8], 0.053499226, 1e-1); // Mean
203 EXPECT_NEAR(sobol_ci[0][8], -0.088307896, 1e-1); // 5% CI
204 EXPECT_NEAR(sobol_ci[1][8], 0.162827882, 1e-1); // 95% CI
205 // ST_4
206 EXPECT_NEAR(sobol[9], 0.030497977, 1e-1); // Mean
207 EXPECT_NEAR(sobol_ci[0][9], -0.113473882, 1e-1); // 5% CI
208 EXPECT_NEAR(sobol_ci[1][9], 0.140750264, 1e-1); // 95% CI
209 // ST_5
210 EXPECT_NEAR(sobol[10], 0.022088362, 1e-1); // Mean
211 EXPECT_NEAR(sobol_ci[0][10], -0.123542952, 1e-1); // 5% CI
212 EXPECT_NEAR(sobol_ci[1][10], 0.134539788, 1e-1); // 95% CI
213 // ST_6
214 EXPECT_NEAR(sobol[11], 0.020756481, 1e-1); // Mean
215 EXPECT_NEAR(sobol_ci[0][11], -0.124872259, 1e-1); // 5% CI
216 EXPECT_NEAR(sobol_ci[1][11], 0.133335504, 1e-1); // 95% CI
217
218 // S_21
219 EXPECT_NEAR(sobol[12], 0.086623495, 1e-1); // Mean
220 EXPECT_NEAR(sobol_ci[0][12], -0.106884750, 1e-1); // 5% CI
221 EXPECT_NEAR(sobol_ci[1][12], 0.292478615, 1e-1); // 95% CI
222 // S_31
223 EXPECT_NEAR(sobol[13], 0.051499920, 1e-2); // Mean
224 EXPECT_NEAR(sobol_ci[0][13], -0.098917644, 1e-2); // 5% CI
225 EXPECT_NEAR(sobol_ci[1][13], 0.208866009, 1e-2); // 95% CI
226 // S_32
227 EXPECT_NEAR(sobol[14], -0.013129111, 1e-1); // Mean
228 EXPECT_NEAR(sobol_ci[0][14], -0.063644133, 1e-1); // 5% CI
229 EXPECT_NEAR(sobol_ci[1][14], 0.034202843, 2e-1); // 95% CI
230 // S_41
231 EXPECT_NEAR(sobol[15], 0.028748451, 1e-2); // Mean
232 EXPECT_NEAR(sobol_ci[0][15], -0.114335284, 1e-2); // 5% CI
233 EXPECT_NEAR(sobol_ci[1][15], 0.180976397, 1e-2); // 95% CI
234 // S_42
235 EXPECT_NEAR(sobol[16], -0.020848158, 1e-1); // Mean
236 EXPECT_NEAR(sobol_ci[0][16], -0.066521659, 1e-1); // 5% CI
237 EXPECT_NEAR(sobol_ci[1][16], 0.021192582, 2e-1); // 95% CI
238 // S_43
239 EXPECT_NEAR(sobol[17], 0.003324699, 1e-1); // Mean
240 EXPECT_NEAR(sobol_ci[0][17], -0.000940639, 1e-1); // 5% CI
241 EXPECT_NEAR(sobol_ci[1][17], 0.008226253, 1e-1); // 95% CI
242 // S_51
243 EXPECT_NEAR(sobol[18], 0.024066263, 1e-1); // Mean
244 EXPECT_NEAR(sobol_ci[0][18], -0.118856731, 1e-1); // 5% CI
245 EXPECT_NEAR(sobol_ci[1][18], 0.173828068, 2e-1); // 95% CI
246 // S_52
247 EXPECT_NEAR(sobol[19], -0.019734912, 1e-2); // Mean
248 EXPECT_NEAR(sobol_ci[0][19], -0.064960642, 1e-2); // 5% CI
249 EXPECT_NEAR(sobol_ci[1][19], 0.021734891, 1e-2); // 95% CI
250 // S_53
251 EXPECT_NEAR(sobol[20], 0.002819696, 1e-1); // Mean
252 EXPECT_NEAR(sobol_ci[0][20], -0.000486192, 1e-1); // 5% CI
253 EXPECT_NEAR(sobol_ci[1][20], 0.006827348, 1e-1); // 95% CI
254 // S_54
255 EXPECT_NEAR(sobol[21], 0.000065586, 1e-2); // Mean
256 EXPECT_NEAR(sobol_ci[0][21], -0.000178457, 1e-2); // 5% CI
257 EXPECT_NEAR(sobol_ci[1][21], 0.000310071, 1e-2); // 95% CI
258 // S_61
259 EXPECT_NEAR(sobol[22], 0.025259517, 1e-1); // Mean
260 EXPECT_NEAR(sobol_ci[0][22], -0.117947309, 2e-1); // 5% CI
261 EXPECT_NEAR(sobol_ci[1][22], 0.175236100, 2e-1); // 95% CI
262 // S_62
263 EXPECT_NEAR(sobol[23], -0.019851829, 1e-1); // Mean
264 EXPECT_NEAR(sobol_ci[0][23], -0.065106309, 1e-1); // 5% CI
265 EXPECT_NEAR(sobol_ci[1][23], 0.021603718, 1e-1); // 95% CI
266 // S_63
267 EXPECT_NEAR(sobol[24], 0.002859528, 1e-2); // Mean
268 EXPECT_NEAR(sobol_ci[0][24], -0.000404042, 1e-2); // 5% CI
269 EXPECT_NEAR(sobol_ci[1][24], 0.006833422, 1e-2); // 95% CI
270 // S_64
271 EXPECT_NEAR(sobol[25], 0.000184449, 1e-2); // Mean
272 EXPECT_NEAR(sobol_ci[0][25], -0.000042626, 1e-2); // 5% CI
273 EXPECT_NEAR(sobol_ci[1][25], 0.000422993, 1e-2); // 95% CI
274 // S_65
275 EXPECT_NEAR(sobol[26], -0.000003882, 1e-2); // Mean
276 EXPECT_NEAR(sobol_ci[0][26], -0.000012806, 1e-2); // 5% CI
277 EXPECT_NEAR(sobol_ci[1][26], 0.000004494, 1e-2); // 95% CI
278 }
279}
280
281TEST(StochasticTools, Sobol_Analytical)
282{
283 // Computes results to compare to analytic values presented by Saltelly and Sobol (1995):
284 // "About the use of rank transformation in sensitivity analysis of model output."
285
286 // Compute SOBOL indices
287 Parallel::Communicator comm;
288 libMesh::ParallelObject po(comm);
289
290 {
291 // Compute SOBOL vectors of g_function
292 std::vector<Real> q_vector = {0, 0, 0, 0};
293 std::vector<std::vector<Real>> data = sobolidx(q_vector, 1000000);
294 SobolCalculator<std::vector<Real>, Real> calc(po, "SOBOL", true);
295 std::vector<Real> sobol = calc.compute(data, false);
296
297 // p. 235
298 EXPECT_EQ(sobol.size(), (std::size_t)14);
299 EXPECT_NEAR(sobol[0], 0.154, 1e-2);
300 EXPECT_NEAR(sobol[1], 0.154, 1e-2);
301 EXPECT_NEAR(sobol[2], 0.154, 1e-2);
302 EXPECT_NEAR(sobol[3], 0.154, 1e-2);
303
304 EXPECT_NEAR(sobol[4], 0.360, 1e-2);
305 EXPECT_NEAR(sobol[5], 0.360, 1e-2);
306 EXPECT_NEAR(sobol[6], 0.360, 1e-2);
307 EXPECT_NEAR(sobol[7], 0.360, 1e-2);
308
309 EXPECT_NEAR(sobol[8], 0.051, 1e-2);
310 EXPECT_NEAR(sobol[9], 0.051, 1e-2);
311 EXPECT_NEAR(sobol[10], 0.051, 1e-2);
312 EXPECT_NEAR(sobol[11], 0.051, 1e-2);
313 EXPECT_NEAR(sobol[12], 0.051, 1e-2);
314 EXPECT_NEAR(sobol[13], 0.051, 1e-2);
315 }
316
317 {
318 // Compute SOBOL vectors of g_function
319 std::vector<Real> q_vector = {0, 0, 0, 0};
320 std::vector<std::vector<Real>> data = sobolidx(q_vector, 1000000, false);
321 SobolCalculator<std::vector<Real>, Real> calc(po, "SOBOL", false);
322 std::vector<Real> sobol = calc.compute(data, false);
323
324 // p. 235
325 EXPECT_EQ(sobol.size(), (std::size_t)8);
326 EXPECT_NEAR(sobol[0], 0.154, 1e-2);
327 EXPECT_NEAR(sobol[1], 0.154, 1e-2);
328 EXPECT_NEAR(sobol[2], 0.154, 1e-2);
329 EXPECT_NEAR(sobol[3], 0.154, 1e-2);
330
331 EXPECT_NEAR(sobol[4], 0.360, 1e-2);
332 EXPECT_NEAR(sobol[5], 0.360, 1e-2);
333 EXPECT_NEAR(sobol[6], 0.360, 1e-2);
334 EXPECT_NEAR(sobol[7], 0.360, 1e-2);
335 }
336
337 {
338 std::vector<Real> q_vector = {0, 0, 0, 0, 0, 0, 0, 0};
339 std::vector<std::vector<Real>> data = sobolidx(q_vector, 1000000);
340 SobolCalculator<std::vector<Real>, Real> calc(po, "SOBOL", true);
341 std::vector<Real> sobol = calc.compute(data, false);
342
343 // p. 235
344 EXPECT_EQ(sobol.size(), (std::size_t)44);
345 EXPECT_NEAR(sobol[0], 0.037, 1e-2);
346 EXPECT_NEAR(sobol[1], 0.037, 1e-2);
347 EXPECT_NEAR(sobol[2], 0.037, 1e-2);
348 EXPECT_NEAR(sobol[3], 0.037, 1e-2);
349 EXPECT_NEAR(sobol[4], 0.037, 1e-2);
350 EXPECT_NEAR(sobol[5], 0.037, 1e-2);
351 EXPECT_NEAR(sobol[6], 0.037, 1e-2);
352 EXPECT_NEAR(sobol[7], 0.037, 1e-2);
353
354 EXPECT_NEAR(sobol[16], 0.012, 1e-2);
355 EXPECT_NEAR(sobol[17], 0.012, 1e-2);
356 EXPECT_NEAR(sobol[18], 0.012, 1e-2);
357 EXPECT_NEAR(sobol[19], 0.012, 1e-2);
358 EXPECT_NEAR(sobol[20], 0.012, 1e-2);
359 EXPECT_NEAR(sobol[21], 0.012, 1e-2);
360 EXPECT_NEAR(sobol[22], 0.012, 1e-2);
361 EXPECT_NEAR(sobol[23], 0.012, 1e-2);
362 EXPECT_NEAR(sobol[24], 0.012, 1e-2);
363 EXPECT_NEAR(sobol[25], 0.012, 1e-2);
364 EXPECT_NEAR(sobol[26], 0.012, 1e-2);
365 EXPECT_NEAR(sobol[27], 0.012, 1e-2);
366 EXPECT_NEAR(sobol[28], 0.012, 1e-2);
367 EXPECT_NEAR(sobol[29], 0.012, 1e-2);
368 EXPECT_NEAR(sobol[30], 0.012, 1e-2);
369 EXPECT_NEAR(sobol[31], 0.012, 1e-2);
370 EXPECT_NEAR(sobol[32], 0.012, 1e-2);
371 EXPECT_NEAR(sobol[33], 0.012, 1e-2);
372 EXPECT_NEAR(sobol[34], 0.012, 1e-2);
373 EXPECT_NEAR(sobol[35], 0.012, 1e-2);
374 EXPECT_NEAR(sobol[36], 0.012, 1e-2);
375 EXPECT_NEAR(sobol[37], 0.012, 1e-2);
376 EXPECT_NEAR(sobol[38], 0.012, 1e-2);
377 EXPECT_NEAR(sobol[39], 0.012, 1e-2);
378 EXPECT_NEAR(sobol[40], 0.012, 1e-2);
379 EXPECT_NEAR(sobol[41], 0.012, 1e-2);
380 EXPECT_NEAR(sobol[42], 0.012, 1e-2);
381 EXPECT_NEAR(sobol[43], 0.012, 1e-2);
382 }
383
384 {
385 std::vector<Real> q_vector = {0, 0, 3, 9, 9, 9, 9, 9};
386 std::vector<std::vector<Real>> data = sobolidx(q_vector, 1000000);
387 SobolCalculator<std::vector<Real>, Real> calc(po, "SOBOL", true);
388 std::vector<Real> sobol = calc.compute(data, false);
389
390 // p. 235
391 EXPECT_EQ(sobol.size(), (std::size_t)44);
392 EXPECT_NEAR(sobol[8], 0.550, 1e-2);
393 EXPECT_NEAR(sobol[9], 0.550, 1e-2);
394 EXPECT_NEAR(sobol[10], 0.050, 1e-2);
395 EXPECT_NEAR(sobol[11], 0.007, 1e-2);
396 EXPECT_NEAR(sobol[12], 0.007, 1e-2);
397 EXPECT_NEAR(sobol[13], 0.007, 1e-2);
398 EXPECT_NEAR(sobol[14], 0.007, 1e-2);
399 EXPECT_NEAR(sobol[15], 0.007, 1e-2);
400 }
401}
y
const std::vector< double > y
Definition EquilibriumConstantFitTest.C:18
count
unsigned int count
g_function
Real g_function(const std::vector< Real > &q_vector, const DenseMatrix< Real > &data, std::size_t row)
Definition TestStochasticToolsSobolCalculators.C:22
TEST
TEST(StochasticTools, Sobol_Saltelli2002)
Definition TestStochasticToolsSobolCalculators.C:95
evaluate
void evaluate(const std::vector< Real > &q_vector, const DenseMatrix< Real > &data, std::vector< Real > &out)
Definition TestStochasticToolsSobolCalculators.C:31
sobolidx
std::vector< std::vector< Real > > sobolidx(const std::vector< Real > &q_vector, std::size_t K, bool resample=true)
Definition TestStochasticToolsSobolCalculators.C:46
model_association_index
Real model_association_index(const std::vector< Real > &data, std::size_t count)
Definition TestStochasticToolsSobolCalculators.C:40
MooseRandom::seed
void seed(std::size_t i, unsigned int seed)
MooseRandom::rand
Real rand(std::size_t i)
StochasticTools::Calculator::compute
OutType compute(const InType &, bool)
Evaluate the calculator on the full vector of data.
Definition Calculators.h:288
StochasticTools::SobolCalculator
Calculator for computing Sobol sensitivity indices according to the paper by Saltelli (2002) https://...
Definition SobolCalculators.h:26
resample
std::vector< T > resample(const std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index=0)
StochasticTools
Enum for batch type in stochastic tools MultiApp.
Definition StochasticToolsTypes.h:14
StochasticTools::reshapeVector
std::vector< std::vector< T > > reshapeVector(const std::vector< T > &vec, std::size_t n, bool row_major)
Reshape a vector into matrix-like vector of vectors.
Definition StochasticToolsUtils.h:259
StochasticTools::makeBootstrapCalculator
std::unique_ptr< BootstrapCalculator< InType, OutType > > makeBootstrapCalculator(const MooseEnum &, const libMesh::ParallelObject &, const std::vector< Real > &, unsigned int, unsigned int, StochasticTools::Calculator< InType, OutType > &)
Definition BootstrapCalculators.h:183
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Generated on Fri Sep 11 2026 20:37:02 for https://mooseframework.inl.gov by doxygen 1.9.8