KOKO\Mimi
107 lines
4.2 KiB
C++
107 lines
4.2 KiB
C++
#ifndef FESA_ANALYSIS_PREPARED_ANALYSIS_H_
|
|
#define FESA_ANALYSIS_PREPARED_ANALYSIS_H_
|
|
|
|
#include <filesystem>
|
|
#include <variant>
|
|
#include <vector>
|
|
|
|
#include "fesa/analysis/analysis_state.h"
|
|
#include "fesa/analysis/dynamic_analysis_state.h"
|
|
#include "fesa/analysis/eigen_analysis_state.h"
|
|
#include "fesa/analysis/nonlinear_analysis_state.h"
|
|
#include "fesa/analysis/solid_frequency_state.h"
|
|
#include "fesa/analysis/solid_hht_dynamic_procedure.h"
|
|
#include "fesa/analysis/solid_static_procedure.h"
|
|
#include "fesa/analysis/transient_heat_procedure.h"
|
|
#include "fesa/core/diagnostic.h"
|
|
#include "fesa/core/status.h"
|
|
#include "fesa/model/domain.h"
|
|
|
|
namespace fesa {
|
|
|
|
class LinearStaticProcedureExecutor;
|
|
class LinearFrequencyProcedureExecutor;
|
|
class EigenResultsWriter;
|
|
class NewtonIterationLogWriter;
|
|
class NonlinearResultsWriter;
|
|
class NonlinearStaticProcedureExecutor;
|
|
class ResultsWriter;
|
|
class HhtDynamicProcedureExecutor;
|
|
class DynamicResultsWriter;
|
|
class ThermalResultsWriter;
|
|
class SolidResultsWriter;
|
|
class SolidFrequencyProcedureExecutor;
|
|
struct DerivedOutputPaths;
|
|
|
|
/// @brief Owns one parsed and semantically mapped analysis input.
|
|
struct PreparedAnalysisInput {
|
|
Domain domain;
|
|
std::vector<Diagnostic> diagnostics;
|
|
};
|
|
|
|
/// @brief Parses and maps an input file exactly once for procedure execution.
|
|
/// @param input_path Source Abaqus input path.
|
|
/// @return A movable Domain and sorted mapping diagnostics, or an input
|
|
/// failure.
|
|
Result<PreparedAnalysisInput> PrepareAnalysisInput(
|
|
const std::filesystem::path& input_path);
|
|
|
|
/// @brief Stores a completed linear-static calculation before result writing.
|
|
struct LinearStaticExecutionResult {
|
|
AnalysisState state;
|
|
std::vector<Diagnostic> diagnostics;
|
|
};
|
|
|
|
/// @brief Stores a completed nonlinear-static calculation before result
|
|
/// writing.
|
|
struct NonlinearStaticExecutionResult {
|
|
NonlinearAnalysisState state;
|
|
std::vector<Diagnostic> diagnostics;
|
|
};
|
|
|
|
/// @brief Stores a complete HHT history before atomic result finalization.
|
|
struct DynamicExecutionResult {
|
|
DynamicAnalysisState state;
|
|
std::vector<Diagnostic> diagnostics;
|
|
};
|
|
|
|
using PreparedAnalysisOutcome =
|
|
std::variant<LinearStaticExecutionResult, NonlinearStaticExecutionResult,
|
|
EigenAnalysisState, DynamicExecutionResult,
|
|
ThermalExecutionResult, SolidStaticExecutionResult,
|
|
SolidFrequencyState, SolidDynamicExecutionResult>;
|
|
|
|
/// @brief Selects the approved procedure from a prepared Domain.
|
|
/// @pre The executors and log outlive this call.
|
|
/// @param thermal_executor Required only for a thermal Domain, whose structural
|
|
/// step collection is empty; absence returns a solver failure.
|
|
/// @return A validated procedure outcome without opening a result file.
|
|
Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
|
|
const Domain& domain, LinearStaticProcedureExecutor& linear_executor,
|
|
NonlinearStaticProcedureExecutor& nonlinear_executor,
|
|
const LinearFrequencyProcedureExecutor& frequency_executor,
|
|
NewtonIterationLogWriter& log,
|
|
const HhtDynamicProcedureExecutor* dynamic_executor = nullptr,
|
|
const TransientHeatProcedureExecutor* thermal_executor = nullptr,
|
|
const SolidStaticProcedureExecutor* solid_static_executor = nullptr,
|
|
const SolidFrequencyProcedureExecutor* solid_frequency_executor = nullptr,
|
|
const SolidHhtDynamicProcedureExecutor* solid_dynamic_executor = nullptr);
|
|
|
|
/// @brief Writes an already computed outcome to its authoritative result file.
|
|
/// @pre The Newton log has closed successfully before this function is called.
|
|
/// @param thermal_writer Required only for a thermal outcome; absence returns
|
|
/// an output failure without opening the final result.
|
|
/// @return Success after the selected writer atomically finalizes its result.
|
|
Status FinalizePreparedAnalysisResult(
|
|
const DerivedOutputPaths& paths, const Domain& domain,
|
|
const PreparedAnalysisOutcome& outcome,
|
|
const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
|
|
NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer,
|
|
DynamicResultsWriter* dynamic_writer = nullptr,
|
|
ThermalResultsWriter* thermal_writer = nullptr,
|
|
SolidResultsWriter* solid_writer = nullptr);
|
|
|
|
} // namespace fesa
|
|
|
|
#endif // FESA_ANALYSIS_PREPARED_ANALYSIS_H_
|