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