SedSat3 1.1.6
Sediment Source Apportionment Tool - Advanced statistical methods for environmental pollution research
Loading...
Searching...
No Matches
results.cpp
Go to the documentation of this file.
1#include "results.h"
2#include "resultitem.h"
3#include "contribution.h"
4#include "elemental_profile_set.h"
5#include "rangeset.h"
6#include "cmbvectorset.h"
7#include "cmbvectorsetset.h"
8
9Results::Results()
10{
11
12}
13
14Results::Results(const Results &rhs): map<string, ResultItem>(rhs)
15{
16 name = rhs.name;
17}
18Results& Results::operator = (const Results &rhs)
19{
20 map<string, ResultItem>::operator=(rhs);
21 name = rhs.name;
22 return *this;
23}
24
25void Results::Append(const ResultItem &ritem)
26{
27 operator[](aquiutils::numbertostring(int(size())+1)+":"+ ritem.Name()) = ritem;
28}
29
30QJsonObject Results::toJsonObject()
31{
32 QJsonObject out;
33 for (map<string,ResultItem>::iterator it = begin(); it!=end(); it++)
34 {
35 out[QString::fromStdString(it->first)] = it->second.Result()->toJsonObject();
36 }
37 return out;
38
39}
40
41bool Results::ReadFromJson(const QJsonObject &jsonobject)
42{
43 for (QString key : jsonobject.keys()) {
44
45 if (key.contains("Contributions"))
46 {
47 Contribution* contribution = new Contribution();
48 contribution->ReadFromJsonObject(jsonobject[key].toObject());
49 ResultItem res_item;
50 res_item.SetName(key.toStdString());
51 res_item.SetShowAsString(true);
52 res_item.SetShowTable(true);
53 res_item.SetType(result_type::contribution);
54 res_item.SetResult(contribution);
55 operator[](key.toStdString()) = res_item;
56 }
57 else if (key.contains("Modeled Elemental Profile"))
58 {
59 Elemental_Profile* modeled = new Elemental_Profile();
60 modeled->ReadFromJsonObject(jsonobject[key].toObject());
61 ResultItem res_item;
62 res_item.SetName(key.toStdString());
63 res_item.SetShowAsString(true);
64 res_item.SetShowTable(true);
65 res_item.SetType(result_type::predicted_concentration);
66 res_item.SetYAxisMode(yaxis_mode::log);
67 res_item.SetResult(modeled);
68 operator[](key.toStdString()) = res_item;
69 }
70 else if (key.contains("Multiway Projected Elemental Profiles"))
71 {
72 CMBVectorSetSet* projected_elements = new CMBVectorSetSet();
73 projected_elements->ReadFromJsonObject(jsonobject[key].toObject());
74 ResultItem res_item;
75 res_item.SetShowAsString(true);
76 res_item.SetShowTable(true);
77 res_item.SetShowGraph(true);
78 res_item.SetAbsoluteValue(true);
79 res_item.SetType(result_type::dfa_vectorsetset);
80 res_item.SetName(key.toStdString());
81 res_item.SetYAxisMode(yaxis_mode::normal);
82 res_item.SetResult(projected_elements);
83 operator[](key.toStdString()) = res_item;
84 }
85 else if (key.contains("Projected Elemental Profiles"))
86 {
87 CMBVectorSet* projected_elements = new CMBVectorSet();
88 projected_elements->ReadFromJsonObject(jsonobject[key].toObject());
89 ResultItem res_item;
90 res_item.SetShowAsString(true);
91 res_item.SetShowTable(true);
92 res_item.SetShowGraph(true);
93 res_item.SetAbsoluteValue(true);
94 res_item.SetType(result_type::vectorset_groups);
95 res_item.SetName(key.toStdString());
96 res_item.SetYAxisMode(yaxis_mode::log);
97 res_item.SetResult(projected_elements);
98 operator[](key.toStdString()) = res_item;
99 }
100 else if (key.contains("Elemental Profiles"))
101 {
102 Elemental_Profile_Set* modeled = new Elemental_Profile_Set();
103 modeled->ReadFromJsonObject(jsonobject[key].toObject());
104 ResultItem res_item;
105 res_item.SetName(key.toStdString());
106 res_item.SetShowAsString(true);
107 res_item.SetShowTable(true);
108 res_item.SetType(result_type::elemental_profile_set);
109 res_item.SetResult(modeled);
110 operator[](key.toStdString()) = res_item;
111 }
112 else if (key.contains("Observed vs Modeled Elemental Profile"))
113 {
114 Elemental_Profile_Set* modeled_vs_measured = new Elemental_Profile_Set();
115 modeled_vs_measured->ReadFromJsonObject(jsonobject[key].toObject());
116 ResultItem res_item;
117 res_item.SetName(key.toStdString());
118 res_item.SetShowAsString(true);
119 res_item.SetShowTable(true);
120 res_item.SetType(result_type::elemental_profile_set);
121 res_item.SetResult(modeled_vs_measured);
122 operator[](key.toStdString()) = res_item;
123 }
124 else if (key.contains("OM & Size MLR for "))
125 {
126 MultipleLinearRegressionSet* mlrset = new MultipleLinearRegressionSet();
127 mlrset->ReadFromJsonObject(jsonobject[key].toObject());
128 ResultItem res_item;
129 res_item.SetName(key.toStdString());
130 res_item.SetShowAsString(true);
131 res_item.SetShowTable(true);
132 res_item.SetType(result_type::mlrset);
133 res_item.SetResult(mlrset);
134 operator[](key.toStdString()) = res_item;
135 }
136 else if (key.contains("MCMC samples"))
137 {
138 CMBTimeSeriesSet* samples = new CMBTimeSeriesSet();
139 samples->ReadFromJsonObject(jsonobject[key].toObject());
140 ResultItem res_item;
141 res_item.SetName(key.toStdString());
142 res_item.SetShowAsString(false);
143 res_item.SetType(result_type::mcmc_samples);
144 res_item.SetResult(samples);
145 operator[](key.toStdString()) = res_item;
146 }
147 else if (key.contains("Posterior Distributions"))
148 {
149 CMBTimeSeriesSet* samples = new CMBTimeSeriesSet();
150 samples->ReadFromJsonObject(jsonobject[key].toObject());
151 ResultItem res_item;
152 res_item.SetShowAsString(false);
153 res_item.SetShowAsString(true);
154 res_item.SetShowTable(true);
155 res_item.SetName(key.toStdString());
156 res_item.SetType(result_type::distribution);
157 res_item.SetResult(samples);
158 operator[](key.toStdString()) = res_item;
159 }
160 else if (key.contains("Source Contribution Credible Intervals"))
161 {
162 RangeSet* rangeset = new RangeSet();
163 rangeset->ReadFromJsonObject(jsonobject[key].toObject());
164 ResultItem res_item;
165 res_item.SetShowAsString(true);
166 res_item.SetType(result_type::rangeset);
167 res_item.SetName(key.toStdString());
168 res_item.SetShowAsString(true);
169 res_item.SetShowTable(true);
170 res_item.SetResult(rangeset);
171 res_item.SetYAxisMode(yaxis_mode::log);
172 res_item.SetYLimit(_range::high, 1.0);
173 operator[](key.toStdString()) = res_item;
174 }
175 else if (key.contains("Posterior Predicted Constituents"))
176 {
177 CMBTimeSeriesSet* posterior_predicted_distribution = new CMBTimeSeriesSet();
178 posterior_predicted_distribution->ReadFromJsonObject(jsonobject[key].toObject());
179 ResultItem res_item;
180 res_item.SetShowAsString(false);
181 res_item.SetType(result_type::distribution_with_observed);
182 res_item.SetName(key.toStdString());
183 res_item.SetResult(posterior_predicted_distribution);
184 operator[](key.toStdString()) = res_item;
185 }
186 else if (key.contains("Predicted Samples Credible Intervals"))
187 {
188 RangeSet* rangeset = new RangeSet();
189 rangeset->ReadFromJsonObject(jsonobject[key].toObject());
190 ResultItem res_item;
191 res_item.SetShowAsString(true);
192 res_item.SetShowAsString(true);
193 res_item.SetShowTable(true);
194 res_item.SetType(result_type::rangeset_with_observed);
195 res_item.SetName(key.toStdString());
196 res_item.SetYAxisMode(yaxis_mode::log);
197 res_item.SetResult(rangeset);
198 operator[](key.toStdString()) = res_item;
199 }
200 else if (key.contains("Stepwise DFA"))
201 {
202 CMBVector* dfaresults = new CMBVector();
203 dfaresults->ReadFromJsonObject(jsonobject[key].toObject());
204 ResultItem res_item;
205 res_item.SetShowAsString(true);
206 res_item.SetShowTable(true);
207 res_item.SetShowGraph(true);
208 res_item.SetAbsoluteValue(true);
209 res_item.SetType(result_type::vector);
210 res_item.SetName(key.toStdString());
211 res_item.SetYAxisMode(yaxis_mode::log);
212 res_item.SetResult(dfaresults);
213 operator[](key.toStdString()) = res_item;
214 }
215 else if (key.contains("Multigroup DFA Analysis"))
216 {
217 CMBMatrix* dfaresults = new CMBMatrix();
218 dfaresults->ReadFromJsonObject(jsonobject[key].toObject());
219 ResultItem res_item;
220 res_item.SetShowAsString(true);
221 res_item.SetShowTable(true);
222 res_item.SetShowGraph(true);
223 res_item.SetAbsoluteValue(true);
224 res_item.SetType(result_type::matrix);
225 res_item.SetName(key.toStdString());
226 res_item.SetYAxisMode(yaxis_mode::log);
227 res_item.SetResult(dfaresults);
228 operator[](key.toStdString()) = res_item;
229 }
230 else if (key.contains("DFA "))
231 {
232 CMBVector* dfaresults = new CMBVector();
233 dfaresults->ReadFromJsonObject(jsonobject[key].toObject());
234 ResultItem res_item;
235 res_item.SetShowAsString(true);
236 res_item.SetShowTable(true);
237 res_item.SetShowGraph(true);
238 res_item.SetAbsoluteValue(true);
239 res_item.SetType(result_type::vector);
240 res_item.SetName(key.toStdString());
241 res_item.SetYAxisMode(yaxis_mode::log);
242 res_item.SetResult(dfaresults);
243 operator[](key.toStdString()) = res_item;
244 }
245 else if (key.contains("Chi-squared P-Value"))
246 {
247 CMBVector* chisquarepvalue = new CMBVector();
248 chisquarepvalue->ReadFromJsonObject(jsonobject[key].toObject());
249 ResultItem res_item;
250 res_item.SetShowAsString(true);
251 res_item.SetShowTable(true);
252 res_item.SetShowGraph(true);
253 res_item.SetAbsoluteValue(true);
254 res_item.SetType(result_type::vector);
255 res_item.SetName(key.toStdString());
256 res_item.SetYAxisMode(yaxis_mode::log);
257 res_item.SetResult(chisquarepvalue);
258 operator[](key.toStdString()) = res_item;
259 }
260 else if (key.contains("Wilks' Lambda"))
261 {
262 CMBVector* wilkslambda = new CMBVector();
263 wilkslambda->ReadFromJsonObject(jsonobject[key].toObject());
264 ResultItem res_item;
265 res_item.SetShowAsString(true);
266 res_item.SetShowTable(true);
267 res_item.SetShowGraph(true);
268 res_item.SetAbsoluteValue(true);
269 res_item.SetType(result_type::vector);
270 res_item.SetName(key.toStdString());
271 res_item.SetYAxisMode(yaxis_mode::log);
272 res_item.SetYLimit(_range::high,1);
273 res_item.SetResult(wilkslambda);
274 operator[](key.toStdString()) = res_item;
275 }
276 else if (key.contains("F-test P-Value"))
277 {
278 CMBVector* ftestpvalue = new CMBVector();
279 ftestpvalue->ReadFromJsonObject(jsonobject[key].toObject());
280 ResultItem res_item;
281 res_item.SetShowAsString(true);
282 res_item.SetShowTable(true);
283 res_item.SetShowGraph(true);
284 res_item.SetAbsoluteValue(true);
285 res_item.SetType(result_type::vector);
286 res_item.SetName(key.toStdString());
287 res_item.SetYAxisMode(yaxis_mode::log);
288 res_item.SetResult(ftestpvalue);
289 operator[](key.toStdString()) = res_item;
290 }
291 else if (key.contains("Eigen vector"))
292 {
293 CMBVector* eigenvector = new CMBVector();
294 eigenvector->ReadFromJsonObject(jsonobject[key].toObject());
295 ResultItem res_item;
296 res_item.SetShowAsString(true);
297 res_item.SetShowTable(true);
298 res_item.SetShowGraph(true);
299 res_item.SetAbsoluteValue(true);
300 res_item.SetType(result_type::vector);
301 res_item.SetName(key.toStdString());
302 res_item.SetYAxisMode(yaxis_mode::log);
303 res_item.SetResult(eigenvector);
304 operator[](key.toStdString()) = res_item;
305 }
306 else if (key.contains("Box-Cox parameters"))
307 {
308 CMBVector* dfaresults = new CMBVector();
309 dfaresults->ReadFromJsonObject(jsonobject[key].toObject());
310 ResultItem res_item;
311 res_item.SetShowAsString(true);
312 res_item.SetShowTable(true);
313 res_item.SetShowGraph(false);
314 res_item.SetAbsoluteValue(true);
315 res_item.SetType(result_type::vector);
316 res_item.SetName(key.toStdString());
317 res_item.SetResult(dfaresults);
318 operator[](key.toStdString()) = res_item;
319 }
320 else if (key.contains("DFA transformed"))
321 {
322 CMBMatrix* dfaresults = new CMBMatrix();
323 dfaresults->ReadFromJsonObject(jsonobject[key].toObject());
324 ResultItem res_item;
325 res_item.SetShowAsString(true);
326 res_item.SetShowTable(true);
327 res_item.SetShowGraph(true);
328 res_item.SetType(result_type::matrix1vs1);
329 res_item.SetName(key.toStdString());
330 res_item.SetResult(dfaresults);
331 operator[](key.toStdString()) = res_item;
332 }
333 else if (key.contains("Correlation Matrix"))
334 {
335 CMBMatrix* dfaresults = new CMBMatrix();
336 dfaresults->ReadFromJsonObject(jsonobject[key].toObject());
337 dfaresults->SetLimit(_range::low, -0.75);
338 dfaresults->SetLimit(_range::high, 0.75);
339 ResultItem res_item;
340 res_item.SetShowAsString(true);
341 res_item.SetShowTable(true);
342 res_item.SetShowGraph(false);
343 res_item.SetType(result_type::matrix);
344 res_item.SetName(key.toStdString());
345 res_item.SetResult(dfaresults);
346 operator[](key.toStdString()) = res_item;
347 }
348 else if (key.contains("Covariance Matrix"))
349 {
350 CMBMatrix* dfaresults = new CMBMatrix();
351 dfaresults->ReadFromJsonObject(jsonobject[key].toObject());
352 ResultItem res_item;
353 res_item.SetShowAsString(true);
354 res_item.SetShowTable(true);
355 res_item.SetShowGraph(false);
356 res_item.SetType(result_type::matrix);
357 res_item.SetName(key.toStdString());
358 res_item.SetResult(dfaresults);
359 operator[](key.toStdString()) = res_item;
360 }
361 else if (key.contains("Bracketing results"))
362 {
363 CMBMatrix* bracketingresults = new CMBMatrix();
364 bracketingresults->ReadFromJsonObject(jsonobject[key].toObject());
365 bracketingresults->SetBooleanValue(true);
366 ResultItem res_item;
367 res_item.SetShowAsString(false);
368 res_item.SetShowTable(true);
369 res_item.SetShowGraph(false);
370 res_item.SetType(result_type::vector);
371 res_item.SetName(key.toStdString());
372 res_item.SetYAxisMode(yaxis_mode::normal);
373 res_item.SetResult(bracketingresults);
374 operator[](key.toStdString()) = res_item;
375 }
376 else if (key.contains("Outlier Analysis"))
377 {
378 CMBMatrix* outliermatrix = new CMBMatrix();
379 outliermatrix->ReadFromJsonObject(jsonobject[key].toObject());
380 outliermatrix->SetLimit(_range::high, 3);
381 outliermatrix->SetLimit(_range::low, -3);
382
383 ResultItem res_item;
384 res_item.SetShowAsString(false);
385 res_item.SetShowTable(true);
386 res_item.SetShowGraph(false);
387 res_item.SetType(result_type::matrix);
388 res_item.SetName(key.toStdString());
389 res_item.SetResult(outliermatrix);
390 operator[](key.toStdString()) = res_item;
391 }
392 else if (key.contains("Kolmogorov–Smirnov statististics for constituent"))
393 {
394 CMBTimeSeriesSet* KSResults = new CMBTimeSeriesSet();
395 KSResults->ReadFromJsonObject(jsonobject[key].toObject());
396
397 ResultItem res_item;
398 res_item.SetShowAsString(false);
399 res_item.SetShowTable(false);
400 res_item.SetShowGraph(true);
401 res_item.SetType(result_type::timeseries_set);
402 res_item.SetName(key.toStdString());
403 res_item.SetResult(KSResults);
404 operator[](key.toStdString()) = res_item;
405 }
406 else if (key.contains("Kolmogorov–Smirnov statististics"))
407 {
408 CMBVector* KSResults = new CMBVector();
409 KSResults->ReadFromJsonObject(jsonobject[key].toObject());
410
411 ResultItem res_item;
412 res_item.SetShowAsString(true);
413 res_item.SetShowTable(true);
414 res_item.SetShowGraph(true);
415 res_item.SetYAxisMode(yaxis_mode::normal);
416 res_item.SetType(result_type::vector);
417 res_item.SetName(key.toStdString());
418 res_item.SetResult(KSResults);
419 operator[](key.toStdString()) = res_item;
420 }
421 else if (key == "Multi-way element discriminant power")
422 {
423 Elemental_Profile_Set* modeled = new Elemental_Profile_Set();
424 modeled->ReadFromJsonObject(jsonobject[key].toObject());
425 ResultItem res_item;
426 res_item.SetName(key.toStdString());
427 res_item.SetShowAsString(true);
428 res_item.SetShowTable(true);
429 res_item.SetType(result_type::elemental_profile_set);
430 res_item.SetYAxisMode(yaxis_mode::normal);
431 res_item.SetResult(modeled);
432 res_item.setYAxisTitle("Discrimination power");
433 operator[](key.toStdString()) = res_item;
434 }
435 else if (key == "Multi-way discriminat fraction")
436 {
437 Elemental_Profile_Set* modeled = new Elemental_Profile_Set();
438 modeled->ReadFromJsonObject(jsonobject[key].toObject());
439 ResultItem res_item;
440 res_item.SetName(key.toStdString());
441 res_item.SetShowAsString(true);
442 res_item.SetShowTable(true);
443 res_item.SetType(result_type::elemental_profile_set);
444 res_item.SetYAxisMode(yaxis_mode::normal);
445 res_item.setYAxisTitle("Percentage discriminated");
446 res_item.SetYLimit(_range::high, 1);
447 res_item.SetResult(modeled);
448 operator[](key.toStdString()) = res_item;
449 }
450 else if (key == "Two-way element discriminant power")
451 {
452 Elemental_Profile* modeled = new Elemental_Profile();
453 modeled->ReadFromJsonObject(jsonobject[key].toObject());
454 ResultItem res_item;
455 res_item.SetName(key.toStdString());
456 res_item.SetShowAsString(true);
457 res_item.SetShowTable(true);
458 res_item.SetType(result_type::predicted_concentration);
459 res_item.SetYAxisMode(yaxis_mode::normal);
460 res_item.SetResult(modeled);
461 res_item.setYAxisTitle("Discrimination power");
462 operator[](key.toStdString()) = res_item;
463 }
464 else if (key == "Discriminat fraction")
465 {
466 Elemental_Profile* modeled = new Elemental_Profile();
467 modeled->ReadFromJsonObject(jsonobject[key].toObject());
468 ResultItem res_item;
469 res_item.SetName(key.toStdString());
470 res_item.SetShowAsString(true);
471 res_item.SetShowTable(true);
472 res_item.SetType(result_type::predicted_concentration);
473 res_item.SetYAxisMode(yaxis_mode::normal);
474 res_item.setYAxisTitle("Percentage discriminated");
475 res_item.SetYLimit(_range::high, 1);
476 res_item.SetResult(modeled);
477 operator[](key.toStdString()) = res_item;
478 }
479 else if (key.contains("ANOVA"))
480 {
481 CMBVector* modeled = new CMBVector();
482 modeled->ReadFromJsonObject(jsonobject[key].toObject());
483 ResultItem res_item;
484 res_item.SetName(key.toStdString());
485 res_item.SetShowAsString(true);
486 res_item.SetShowTable(true);
487 res_item.SetShowGraph(true);
488 res_item.SetType(result_type::vector);
489 res_item.SetYAxisMode(yaxis_mode::normal);
490 res_item.setYAxisTitle("P-Value");
491 res_item.SetYLimit(_range::high, 1);
492 res_item.SetResult(modeled);
493 operator[](key.toStdString()) = res_item;
494 }
495 else if (key.contains("Error Analysis"))
496 {
497 CMBTimeSeriesSet* contributions = new CMBTimeSeriesSet();
498 contributions->ReadFromJsonObject(jsonobject[key].toObject());
499 ResultItem res_item;
500 res_item.SetName(key.toStdString());
501 res_item.SetShowAsString(true);
502 res_item.SetShowTable(true);
503 res_item.SetShowGraph(true);
504 res_item.SetType(result_type::stacked_bar_chart);
505 res_item.SetYAxisMode(yaxis_mode::normal);
506 res_item.setYAxisTitle("Contribution");
507 res_item.setXAxisTitle("Sample");
508 res_item.SetYLimit(_range::high, 1);
509 res_item.SetYLimit(_range::low, 0);
510 res_item.SetXAxisMode(xaxis_mode::counter);
511 res_item.SetResult(contributions);
512 operator[](key.toStdString()) = res_item;
513 }
514 else if (key.contains("Source Verification"))
515 {
516 CMBTimeSeriesSet* contributions = new CMBTimeSeriesSet();
517 contributions->ReadFromJsonObject(jsonobject[key].toObject());
518 contributions->GetOptions().X_suffix = "";
519 contributions->GetOptions().Y_suffix = "";
520 contributions->SetOption(options_key::single_column_x, true);
521 ResultItem res_item;
522 res_item.SetName(key.toStdString());
523 res_item.SetShowAsString(true);
524 res_item.SetShowTable(true);
525 res_item.SetShowGraph(true);
526 res_item.SetType(result_type::stacked_bar_chart);
527 res_item.SetYAxisMode(yaxis_mode::normal);
528 res_item.setYAxisTitle("Contribution");
529 res_item.setXAxisTitle("Sample");
530 res_item.SetYLimit(_range::high, 1);
531 res_item.SetYLimit(_range::low, 0);
532 res_item.SetXAxisMode(xaxis_mode::counter);
533 res_item.SetResult(contributions);
534 operator[](key.toStdString()) = res_item;
535 }
536 else if (key.contains("Levenberg-Marquardt-Batch"))
537 {
538 CMBTimeSeriesSet* contributions = new CMBTimeSeriesSet();
539 contributions->ReadFromJsonObject(jsonobject[key].toObject());
540 contributions->GetOptions().X_suffix = "";
541 contributions->GetOptions().Y_suffix = "";
542 contributions->SetOption(options_key::single_column_x, true);
543 ResultItem res_item;
544 res_item.SetName(key.toStdString());
545 res_item.SetShowAsString(true);
546 res_item.SetShowTable(true);
547 res_item.SetShowGraph(true);
548 res_item.SetType(result_type::stacked_bar_chart);
549 res_item.SetYAxisMode(yaxis_mode::normal);
550 res_item.setYAxisTitle("Contribution");
551 res_item.setXAxisTitle("Sample");
552 res_item.SetYLimit(_range::high, 1);
553 res_item.SetYLimit(_range::low, 0);
554 res_item.SetXAxisMode(xaxis_mode::counter);
555 res_item.SetResult(contributions);
556 operator[](key.toStdString()) = res_item;
557 }
558
559
560 }
561 return true;
562
563}
CMBMatrix
Matrix class with labeled rows and columns for Chemical Mass Balance analysis.
Definition cmbmatrix.h:19
CMBMatrix::ReadFromJsonObject
bool ReadFromJsonObject(const QJsonObject &jsonobject) override
Deserializes matrix from JSON format.
Definition cmbmatrix.cpp:67
CMBMatrix::SetBooleanValue
void SetBooleanValue(bool val)
Sets boolean display mode for table widget.
Definition cmbmatrix.h:183
CMBTimeSeriesSet
Collection of time series with labels and observed values.
Definition cmbtimeseriesset.h:17
CMBTimeSeriesSet::ReadFromJsonObject
bool ReadFromJsonObject(const QJsonObject &jsonobject) override
Deserializes time series set from JSON format.
Definition cmbtimeseriesset.cpp:71
CMBVectorSetSet
Collection of named CMBVectorSet objects for hierarchical data organization.
Definition cmbvectorsetset.h:18
CMBVectorSetSet::ReadFromJsonObject
bool ReadFromJsonObject(const QJsonObject &jsonobject) override
Deserializes vector set set from JSON format.
Definition cmbvectorsetset.cpp:28
CMBVectorSet
Collection of named CMBVector objects for multi-variable analysis.
Definition cmbvectorset.h:17
CMBVectorSet::ReadFromJsonObject
bool ReadFromJsonObject(const QJsonObject &jsonobject) override
Deserializes vector set from JSON format.
Definition cmbvectorset.cpp:28
CMBVector
Vector class with string labels for Chemical Mass Balance analysis.
Definition cmbvector.h:17
CMBVector::ReadFromJsonObject
bool ReadFromJsonObject(const QJsonObject &jsonobject) override
Deserializes vector from JSON format.
Definition cmbvector.cpp:81
Contribution
Source contribution container for Chemical Mass Balance results.
Definition contribution.h:22
Elemental_Profile_Set
Manages a collection of elemental profiles (samples) for source fingerprinting analysis.
Definition elemental_profile_set.h:28
Elemental_Profile_Set::ReadFromJsonObject
bool ReadFromJsonObject(const QJsonObject &jsonobject) override
Deserialize object from JSON format.
Definition elemental_profile_set.cpp:311
Elemental_Profile
Container for elemental concentration data of a single sediment sample.
Definition elemental_profile.h:114
Elemental_Profile::ReadFromJsonObject
bool ReadFromJsonObject(const QJsonObject &json) override
Deserialize from JSON object.
Definition elemental_profile.cpp:707
Interface::GetOptions
options & GetOptions()
Get reference to the options structure.
Definition interface.h:275
Interface::SetOption
void SetOption(options_key opt, bool val)
Set a configuration option.
Definition interface.h:250
Interface::SetLimit
void SetLimit(_range lowhigh, const double &value)
Set upper or lower limit for value highlighting.
Definition interface.h:233
Interface::toJsonObject
virtual QJsonObject toJsonObject() const
Serialize object to JSON format.
Definition interface.cpp:27
ResultItem::Name
string Name() const
Definition resultitem.h:22
ResultItem::SetAbsoluteValue
void SetAbsoluteValue(bool val)
Definition resultitem.h:57
ResultItem::SetShowGraph
void SetShowGraph(bool state)
Definition resultitem.h:80
ResultItem::setYAxisTitle
void setYAxisTitle(const string &title)
Definition resultitem.h:39
ResultItem::SetXAxisMode
void SetXAxisMode(xaxis_mode mode)
Definition resultitem.h:26
ResultItem::SetYLimit
void SetYLimit(_range highlow, const double &value)
Definition resultitem.h:66
ResultItem::SetName
void SetName(const string &_name)
Definition resultitem.h:21
ResultItem::Result
Interface * Result() const
Definition resultitem.h:17
ResultItem::SetResult
void SetResult(Interface *_result)
Definition resultitem.h:18
ResultItem::SetShowTable
void SetShowTable(bool state)
Definition resultitem.h:78
ResultItem::setXAxisTitle
void setXAxisTitle(const string &title)
Definition resultitem.h:31
ResultItem::SetYAxisMode
void SetYAxisMode(yaxis_mode mode)
Definition resultitem.h:25
ResultItem::SetShowAsString
void SetShowAsString(bool value)
Definition resultitem.h:29
ResultItem::SetType
void SetType(const result_type &_type)
Definition resultitem.h:23
Results::Append
void Append(const ResultItem &)
Definition results.cpp:25
Results::toJsonObject
QJsonObject toJsonObject()
Definition results.cpp:30
Results::operator=
Results & operator=(const Results &rhs)
Definition results.cpp:18
Results::name
string name
Definition results.h:29
Results::Results
Results()
Definition results.cpp:9
Results::ReadFromJson
bool ReadFromJson(const QJsonObject &jsonobject)
Definition results.cpp:41
elemental_profile_set.h
options_key::single_column_x
@ single_column_x
Enable single-column mode for X-axis data representation.
_range::low
@ low
Lower bound of the parameter range.
_range::high
@ high
Upper bound of the parameter range.
result_type::distribution_with_observed
@ distribution_with_observed
result_type::predicted_concentration
@ predicted_concentration
result_type::rangeset_with_observed
@ rangeset_with_observed
result_type::elemental_profile_set
@ elemental_profile_set
options::X_suffix
QString X_suffix
Suffix appended to X-axis field names in serialization.
Definition interface.h:33
options::Y_suffix
QString Y_suffix
Suffix appended to Y-axis field names in serialization.
Definition interface.h:34