KOKO\Mimi
84 lines
3.6 KiB
C++
84 lines
3.6 KiB
C++
#include "fesa/results/prepared_results_writer.h"
|
|
|
|
#include "fesa/results/dynamic_results_writer.h"
|
|
#include "fesa/results/eigen_results_writer.h"
|
|
#include "fesa/results/nonlinear_results_writer.h"
|
|
#include "fesa/results/results_writer.h"
|
|
#include "fesa/results/solid_results_writer.h"
|
|
#include "fesa/results/thermal_results_writer.h"
|
|
|
|
namespace fesa {
|
|
|
|
Status WritePreparedAnalysisResult(
|
|
const std::filesystem::path& results_path, const Domain& domain,
|
|
const PreparedAnalysisOutcome& outcome,
|
|
const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
|
|
NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer,
|
|
DynamicResultsWriter* dynamic_writer, ThermalResultsWriter* thermal_writer,
|
|
SolidResultsWriter* solid_writer) {
|
|
if (std::holds_alternative<SolidStaticExecutionResult>(outcome) ||
|
|
std::holds_alternative<SolidFrequencyState>(outcome) ||
|
|
std::holds_alternative<SolidDynamicExecutionResult>(outcome)) {
|
|
if (solid_writer == nullptr)
|
|
return Status::Failure(FailureCategory::kOutput,
|
|
{{Severity::kError,
|
|
"missing-solid-writer",
|
|
{},
|
|
"",
|
|
{},
|
|
"Solid result writer is required."}});
|
|
if (const auto* result = std::get_if<SolidStaticExecutionResult>(&outcome))
|
|
return solid_writer->Write(results_path, domain, result->state,
|
|
diagnostics);
|
|
if (const auto* result = std::get_if<SolidFrequencyState>(&outcome))
|
|
return solid_writer->Write(results_path, domain, *result,
|
|
diagnostics);
|
|
return solid_writer->Write(
|
|
results_path, domain,
|
|
std::get<SolidDynamicExecutionResult>(outcome).state, diagnostics);
|
|
}
|
|
if (std::holds_alternative<ThermalExecutionResult>(outcome)) {
|
|
if (thermal_writer == nullptr) {
|
|
return Status::Failure(FailureCategory::kOutput,
|
|
{{Severity::kError,
|
|
"missing-thermal-writer",
|
|
{},
|
|
"HEAT TRANSFER",
|
|
{},
|
|
"Thermal result writer is required."}});
|
|
}
|
|
return thermal_writer->Write(
|
|
results_path, domain,
|
|
std::get<ThermalExecutionResult>(outcome).state, diagnostics);
|
|
}
|
|
if (std::holds_alternative<DynamicExecutionResult>(outcome)) {
|
|
if (dynamic_writer == nullptr)
|
|
return Status::Failure(FailureCategory::kOutput,
|
|
{{Severity::kError,
|
|
"missing-dynamic-writer",
|
|
{},
|
|
"DYNAMIC",
|
|
{},
|
|
"Dynamic result writer is required."}});
|
|
return dynamic_writer->Write(
|
|
results_path, domain,
|
|
std::get<DynamicExecutionResult>(outcome).state, diagnostics);
|
|
}
|
|
if (std::holds_alternative<EigenAnalysisState>(outcome)) {
|
|
return eigen_writer.Write(results_path, domain,
|
|
std::get<EigenAnalysisState>(outcome),
|
|
diagnostics);
|
|
}
|
|
if (std::holds_alternative<LinearStaticExecutionResult>(outcome)) {
|
|
return linear_writer.Write(
|
|
results_path, domain,
|
|
std::get<LinearStaticExecutionResult>(outcome).state, diagnostics);
|
|
}
|
|
|
|
return nonlinear_writer.Write(
|
|
results_path, domain,
|
|
std::get<NonlinearStaticExecutionResult>(outcome).state, diagnostics);
|
|
}
|
|
|
|
} // namespace fesa
|