https://mooseframework.inl.gov
Functions
TestStochasticToolsSobolCalculators.C File Reference

Go to the source code of this file.

Functions

Real g_function (const std::vector< Real > &q_vector, const DenseMatrix< Real > &data, std::size_t row)
 
void evaluate (const std::vector< Real > &q_vector, const DenseMatrix< Real > &data, std::vector< Real > &out)
 
Real model_association_index (const std::vector< Real > &data, std::size_t count)
 
std::vector< std::vector< Real > > sobolidx (const std::vector< Real > &q_vector, std::size_t K, bool resample=true)
 
 TEST (StochasticTools, Sobol_Saltelli2002)
 
 TEST (StochasticTools, Sobol_Analytical)
 

Function Documentation

◆ evaluate()

void evaluate ( const std::vector< Real > &  q_vector,
const DenseMatrix< Real > &  data,
std::vector< Real > &  out 
)

Definition at line 32 of file TestStochasticToolsSobolCalculators.C.

Referenced by MathCTDFreeEnergyTempl< is_ad >::computeQpProperties(), FaceCenteredMapFunctor< Real, std::unordered_map< dof_id_type, Real > >::evaluate(), EvaluateSurrogate::execute(), InverseMapping::execute(), ConditionalSampleReporterTempl< T >::needSample(), and sobolidx().

35 {
36  for (std::size_t i = 0; i < data.m(); ++i)
37  out.push_back(g_function(q_vector, data, i));
38 }
libMesh::DenseMatrix::m
unsigned int m() const
g_function
Real g_function(const std::vector< Real > &q_vector, const DenseMatrix< Real > &data, std::size_t row)
Definition: TestStochasticToolsSobolCalculators.C:23
out
OStreamProxy out

◆ g_function()

Real g_function ( const std::vector< Real > &  q_vector,
const DenseMatrix< Real > &  data,
std::size_t  row 
)

Definition at line 23 of file TestStochasticToolsSobolCalculators.C.

Referenced by evaluate().

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 }
y
const std::vector< double > y
Definition: EquilibriumConstantFitTest.C:18
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
libMesh::DenseMatrix::n
unsigned int n() const

◆ model_association_index()

Real model_association_index ( const std::vector< Real > &  data,
std::size_t  count 
)

Definition at line 41 of file TestStochasticToolsSobolCalculators.C.

42 {
43  return 1 - std::accumulate(data.begin(), data.begin() + count, 0.);
44 }

◆ sobolidx()

std::vector<std::vector<Real> > sobolidx ( const std::vector< Real > &  q_vector,
std::size_t  K,
bool  resample = true 
)

Definition at line 47 of file TestStochasticToolsSobolCalculators.C.

Referenced by TEST().

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 }
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
NS::K
static const std::string K
Definition: NS.h:170
MooseRandom::seed
void seed(std::size_t i, unsigned int seed)
evaluate
void evaluate(const std::vector< Real > &q_vector, const DenseMatrix< Real > &data, std::vector< Real > &out)
Definition: TestStochasticToolsSobolCalculators.C:32
EM::j
static const std::complex< double > j(0, 1)
Complex number "j" (also known as "i")
MooseRandom::rand
Real rand(std::size_t i)

◆ TEST() [1/2]

TEST ( StochasticTools  ,
Sobol_Saltelli2002   
)

Definition at line 96 of file TestStochasticToolsSobolCalculators.C.

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 }
sobolidx
std::vector< std::vector< Real > > sobolidx(const std::vector< Real > &q_vector, std::size_t K, bool resample=true)
Definition: TestStochasticToolsSobolCalculators.C:47
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
StochasticTools::SobolCalculator
Calculator for computing Sobol sensitivity indices according to the paper by Saltelli (2002) https://...
Definition: SobolCalculators.h:24
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:182

◆ TEST() [2/2]

TEST ( StochasticTools  ,
Sobol_Analytical   
)

Definition at line 282 of file TestStochasticToolsSobolCalculators.C.

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 }
sobolidx
std::vector< std::vector< Real > > sobolidx(const std::vector< Real > &q_vector, std::size_t K, bool resample=true)
Definition: TestStochasticToolsSobolCalculators.C:47
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
StochasticTools::SobolCalculator
Calculator for computing Sobol sensitivity indices according to the paper by Saltelli (2002) https://...
Definition: SobolCalculators.h:24
Generated on Thu Jul 17 2025 01:45:03 for https://mooseframework.inl.gov by   doxygen 1.8.14