feat(thermal): connect transient heat application execution

src/fesa/analysis/prepared_analysis.cpp

@@ -14,6 +14,7 @@
 #include "fesa/results/eigen_results_writer.h"
 #include "fesa/results/nonlinear_results_writer.h"
 #include "fesa/results/results_writer.h"
+#include "fesa/results/thermal_results_writer.h"
 
 namespace fesa {
 
@@ -40,7 +41,26 @@ Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
     NonlinearStaticProcedureExecutor& nonlinear_executor,
     const LinearFrequencyProcedureExecutor& frequency_executor,
     NewtonIterationLogWriter& log,
-    const HhtDynamicProcedureExecutor* dynamic_executor) {
+    const HhtDynamicProcedureExecutor* dynamic_executor,
+    const TransientHeatProcedureExecutor* thermal_executor) {
+  if (domain.ThermalStep() != nullptr) {
+    if (thermal_executor == nullptr) {
+      return Result<PreparedAnalysisOutcome>::Failure(
+          Status::Failure(FailureCategory::kSolver,
+                          {{Severity::kError,
+                            "missing-thermal-executor",
+                            {},
+                            "HEAT TRANSFER",
+                            {},
+                            "Thermal execution adapter is required."}}));
+    }
+    auto thermal = thermal_executor->Execute(domain);
+    if (!thermal.HasValue()) {
+      return Result<PreparedAnalysisOutcome>::Failure(thermal.GetStatus());
+    }
+    return Result<PreparedAnalysisOutcome>::Success(
+        PreparedAnalysisOutcome{std::move(thermal.Value())});
+  }
   if (domain.Steps().Size() != 1U) {
     return Result<PreparedAnalysisOutcome>::Failure(Status::Failure(
         FailureCategory::kInput,
@@ -100,7 +120,22 @@ Status FinalizePreparedAnalysisResult(
     const PreparedAnalysisOutcome& outcome,
     const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
     NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer,
-    DynamicResultsWriter* dynamic_writer) {
+    DynamicResultsWriter* dynamic_writer,
+    ThermalResultsWriter* thermal_writer) {
+  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(
+        paths.results_path, domain,
+        std::get<ThermalExecutionResult>(outcome).state, diagnostics);
+  }
   if (std::holds_alternative<DynamicExecutionResult>(outcome)) {
     if (dynamic_writer == nullptr)
       return Status::Failure(FailureCategory::kOutput,

src/fesa/app/fesa_application.cpp

@@ -18,6 +18,7 @@
 #include "fesa/io/hdf5/eigen_hdf5_results_writer.h"
 #include "fesa/io/hdf5/hdf5_results_writer.h"
 #include "fesa/io/hdf5/nonlinear_hdf5_results_writer.h"
+#include "fesa/io/hdf5/thermal_hdf5_results_writer.h"
 #include "fesa/solvers/linear/mkl_pardiso_solver.h"
 #include "fesa/solvers/linear/mkl_pardiso_tangent_solver.h"
 
@@ -87,6 +88,7 @@ int FesaApplication::Run(const std::vector<std::string>& arguments) {
   NonlinearHdf5ResultsWriter nonlinear_writer;
   EigenHdf5ResultsWriter eigen_writer;
   DynamicHdf5ResultsWriter dynamic_writer;
+  ThermalHdf5ResultsWriter thermal_writer;
   NewtonIterationLogWriter log;
 
   Status status = log.Open(paths.Value().log_path);
@@ -106,9 +108,11 @@ int FesaApplication::Run(const std::vector<std::string>& arguments) {
     const LinearFrequencyProcedureExecutor frequency_executor;
     const HhtDynamicProcedureExecutor dynamic_executor(
         parallel_for, linear_solver, tangent_solver);
+    const TransientHeatProcedureExecutor thermal_executor(parallel_for,
+                                                          linear_solver);
     Result<PreparedAnalysisOutcome> outcome = ExecutePreparedAnalysis(
         prepared.Value().domain, linear_executor, nonlinear_executor,
-        frequency_executor, log, &dynamic_executor);
+        frequency_executor, log, &dynamic_executor, &thermal_executor);
     if (!outcome.HasValue()) {
       status = outcome.GetStatus();
     } else {
@@ -120,7 +124,7 @@ int FesaApplication::Run(const std::vector<std::string>& arguments) {
       status = FinalizePreparedAnalysisResult(
           paths.Value(), prepared.Value().domain, outcome.Value(),
           prepared.Value().diagnostics, linear_writer, nonlinear_writer,
-          eigen_writer, &dynamic_writer);
+          eigen_writer, &dynamic_writer, &thermal_writer);
       if (status.IsOk()) {
         return kSuccessExitCode;
       }