KOKO\Mimi
759 lines
37 KiB
C++
759 lines
37 KiB
C++
#include "fesa/io/hdf5/solid_hdf5_results_writer.h"
|
|
|
|
#include <cmath>
|
|
#include <cstring>
|
|
#include <set>
|
|
#include <stdexcept>
|
|
#include <type_traits>
|
|
|
|
#include "fesa/analysis/analysis_model.h"
|
|
#include "fesa/build_info.h"
|
|
#include "fesa/elements/element_factory.h"
|
|
#include "fesa/elements/hex8_element.h"
|
|
#include "fesa/materials/isotropic_linear_elastic_material.h"
|
|
#include "io/hdf5/hdf5_atomic_file.h"
|
|
#include "io/hdf5/hdf5_model_writer.h"
|
|
#include "io/hdf5/hdf5_primitives.h"
|
|
#include "io/hdf5/hdf5_result_writer.h"
|
|
#include "io/hdf5/solid_hdf5_self_check.h"
|
|
#include "math/high_low_arithmetic.h"
|
|
|
|
namespace fesa::hdf5_internal {
|
|
namespace {
|
|
void Check(bool condition, const char* message) {
|
|
if (!condition) throw Hdf5Failure(message);
|
|
}
|
|
using U = std::vector<std::uint64_t>;
|
|
using B = std::vector<std::uint8_t>;
|
|
using D = std::vector<double>;
|
|
using S = std::vector<std::string>;
|
|
void Parent(hid_t file, const std::string& path) {
|
|
const auto parent = path.substr(0, path.find_last_of('/'));
|
|
if (!parent.empty() && H5Lexists(file, parent.c_str(), H5P_DEFAULT) <= 0)
|
|
(void)CreateGroup(file, parent.c_str());
|
|
}
|
|
void Table(hid_t file, const SolidTable& table) {
|
|
Parent(file, table.path);
|
|
std::vector<Hdf5Handle> native, filetypes;
|
|
std::size_t size = 0;
|
|
for (const auto& column : table.columns) {
|
|
native.push_back(SolidColumnType(column, true));
|
|
filetypes.push_back(SolidColumnType(column, false));
|
|
size += H5Tget_size(native.back().Get());
|
|
}
|
|
Hdf5Handle ft{RequireHdf5Id(H5Tcreate(H5T_COMPOUND, size),
|
|
"Solid file compound failed."),
|
|
H5Tclose};
|
|
Hdf5Handle mt{RequireHdf5Id(H5Tcreate(H5T_COMPOUND, size),
|
|
"Solid memory compound failed."),
|
|
H5Tclose};
|
|
std::vector<unsigned char> bytes(table.rows * size);
|
|
std::size_t offset = 0;
|
|
for (std::size_t c = 0; c < table.columns.size(); ++c) {
|
|
const auto& column = table.columns[c];
|
|
RequireHdf5(
|
|
H5Tinsert(ft.Get(), column.name.c_str(), offset, filetypes[c].Get()),
|
|
"Solid file member failed.");
|
|
RequireHdf5(
|
|
H5Tinsert(mt.Get(), column.name.c_str(), offset, native[c].Get()),
|
|
"Solid memory member failed.");
|
|
std::visit(
|
|
[&](const auto& values) {
|
|
using T = typename std::decay_t<decltype(values)>::value_type;
|
|
for (std::size_t row = 0; row < table.rows; ++row) {
|
|
if constexpr (std::is_same_v<T, std::string>) {
|
|
const char* pointer = values[row].c_str();
|
|
std::memcpy(bytes.data() + row * size + offset, &pointer,
|
|
sizeof(pointer));
|
|
} else
|
|
std::memcpy(bytes.data() + row * size + offset,
|
|
values.data() + row * column.width,
|
|
column.width * sizeof(T));
|
|
}
|
|
},
|
|
column.values);
|
|
offset += H5Tget_size(native[c].Get());
|
|
}
|
|
auto dataset = WriteCompoundDataset(file, table.path.c_str(), table.rows,
|
|
ft.Get(), mt.Get(), bytes.data());
|
|
for (const auto& item : table.strings)
|
|
WriteStringAttribute(dataset.Get(), item.first.c_str(), item.second);
|
|
}
|
|
SolidData Data(const std::string& path, std::vector<hsize_t> dimensions,
|
|
D values, const char* names, const char* units,
|
|
const char* location) {
|
|
return {path,
|
|
std::move(dimensions),
|
|
std::move(values),
|
|
{{"component_names", names},
|
|
{"unit_dimensions", units},
|
|
{"coordinate_system", "global-cartesian"},
|
|
{"location", location},
|
|
{"step_name", "Step-1"}},
|
|
{},
|
|
{}};
|
|
}
|
|
void FrameData(SolidPlan& plan, const Domain& domain, std::size_t frame,
|
|
std::size_t increment, double coordinate, bool dynamic,
|
|
const Vector& u, const Vector& rf, const Vector& r,
|
|
const std::vector<SolidIntegrationPointRow>& points,
|
|
double energy) {
|
|
const std::string root = "/steps/Step-1/frames/" + std::to_string(frame);
|
|
const hsize_t n = domain.Nodes().size(), e = domain.Elements().Size();
|
|
const auto add = [&](SolidData value) {
|
|
value.integers = {{"frame_index", frame}, {"increment_index", increment}};
|
|
value.doubles = {{dynamic ? "time" : "load_factor", coordinate}};
|
|
plan.datasets.push_back(std::move(value));
|
|
};
|
|
add(Data(root + "/nodal/displacement", {n, 3}, CopyVectorValues(u), "U1,U2,U3",
|
|
"length", "nodal"));
|
|
add(Data(root + "/nodal/reaction", {n, 3}, CopyVectorValues(rf), "RF1,RF2,RF3", "force",
|
|
"nodal"));
|
|
add(Data(root + "/nodal/residual", {n, 3}, CopyVectorValues(r), "R1,R2,R3", "force",
|
|
"nodal"));
|
|
D stress, strain;
|
|
Check(points.size() == 8 * e, "Solid point count is invalid.");
|
|
for (std::size_t i = 0; i < points.size(); ++i) {
|
|
Check(points[i].element == i / 8 &&
|
|
points[i].integration_point == static_cast<int>(i % 8 + 1),
|
|
"Solid point identity is invalid.");
|
|
stress.insert(stress.end(), points[i].cauchy_stress.begin(),
|
|
points[i].cauchy_stress.end());
|
|
strain.insert(strain.end(), points[i].strain.begin(),
|
|
points[i].strain.end());
|
|
}
|
|
auto s =
|
|
Data(root + "/solid/stress", {e, 8, 6}, std::move(stress),
|
|
"S11,S22,S33,S12,S13,S23", "force/length^2", "integration-point");
|
|
s.strings["stress_measure"] = "cauchy";
|
|
add(std::move(s));
|
|
auto eps =
|
|
Data(root + "/solid/strain", {e, 8, 6}, std::move(strain),
|
|
"E11,E22,E33,E12,E13,E23", "dimensionless", "integration-point");
|
|
eps.strings["strain_measure"] = domain.Steps()[0].UsesNonlinearGeometry()
|
|
? "green-lagrange"
|
|
: "infinitesimal";
|
|
eps.strings["shear_convention"] = "tensor";
|
|
add(std::move(eps));
|
|
auto en = Data(root + "/global/strain_energy", {}, D{energy}, "scalar",
|
|
"force*length", "global");
|
|
en.strings["definition"] = domain.Steps()[0].UsesNonlinearGeometry()
|
|
? "sum(W*detJ0)"
|
|
: "0.5*u^T*K0*u";
|
|
add(std::move(en));
|
|
}
|
|
void Model(SolidPlan& plan, const Domain& domain, const DofManager& dofs) {
|
|
SolidTable nodes{"/model/nodes",
|
|
domain.Nodes().size(),
|
|
{{"internal_node_id", 1, U{}},
|
|
{"instance_name", 1, S{}},
|
|
{"source_label", 1, S{}},
|
|
{"coordinates", 3, D{}}}};
|
|
for (std::size_t i = 0; i < domain.Nodes().size(); ++i) {
|
|
const auto& node = domain.Nodes()[i];
|
|
std::get<U>(nodes.columns[0].values).push_back(i);
|
|
std::get<S>(nodes.columns[1].values)
|
|
.push_back(node.source_id.instance_name);
|
|
std::get<S>(nodes.columns[2].values)
|
|
.push_back(node.source_id.source_label_text);
|
|
auto& coords = std::get<D>(nodes.columns[3].values);
|
|
coords.insert(coords.end(), node.coordinates.begin(),
|
|
node.coordinates.end());
|
|
}
|
|
plan.tables.push_back(std::move(nodes));
|
|
SolidTable elements{"/model/elements",
|
|
domain.SolidElements().Size(),
|
|
{{"internal_element_id", 1, U{}},
|
|
{"instance_name", 1, S{}},
|
|
{"source_label", 1, S{}},
|
|
{"source_element_type", 1, S{}},
|
|
{"internal_formulation", 1, S{}},
|
|
{"node_internal_ids", 8, U{}},
|
|
{"solid_section_internal_id", 1, U{}},
|
|
{"material_internal_id", 1, U{}}}};
|
|
for (std::size_t i = 0; i < domain.SolidElements().Size(); ++i) {
|
|
const auto& element = domain.SolidElements()[i];
|
|
std::get<U>(elements.columns[0].values).push_back(i);
|
|
std::get<S>(elements.columns[1].values)
|
|
.push_back(element.SourceId().instance_name);
|
|
std::get<S>(elements.columns[2].values)
|
|
.push_back(element.SourceId().source_label_text);
|
|
std::get<S>(elements.columns[3].values)
|
|
.push_back(std::string(element.SourceElementType()));
|
|
std::get<S>(elements.columns[4].values).push_back("FESA-Hex8");
|
|
auto& connectivity = std::get<U>(elements.columns[5].values);
|
|
connectivity.insert(connectivity.end(), element.node_indices.begin(),
|
|
element.node_indices.end());
|
|
std::get<U>(elements.columns[6].values).push_back(element.section_index);
|
|
std::get<U>(elements.columns[7].values).push_back(element.MaterialIndex());
|
|
}
|
|
plan.tables.push_back(std::move(elements));
|
|
SolidTable materials{"/model/solid/materials",
|
|
domain.Materials().Size(),
|
|
{{"internal_material_id", 1, U{}},
|
|
{"name", 1, S{}},
|
|
{"youngs_modulus", 1, D{}},
|
|
{"poisson_ratio", 1, D{}},
|
|
{"density_present", 1, B{}},
|
|
{"density", 1, D{}}}};
|
|
for (std::size_t i = 0; i < domain.Materials().Size(); ++i) {
|
|
const auto* material =
|
|
dynamic_cast<const LinearElasticMaterial*>(&domain.Materials()[i]);
|
|
Check(material != nullptr, "Solid material is not isotropic elastic.");
|
|
bool present = false;
|
|
double rho = 0;
|
|
for (const auto& density : domain.Densities())
|
|
if (density.material_index == i) {
|
|
present = true;
|
|
rho = density.rho;
|
|
}
|
|
std::get<U>(materials.columns[0].values).push_back(i);
|
|
std::get<S>(materials.columns[1].values).push_back(material->Name());
|
|
std::get<D>(materials.columns[2].values)
|
|
.push_back(material->YoungsModulus());
|
|
std::get<D>(materials.columns[3].values)
|
|
.push_back(material->PoissonsRatio());
|
|
std::get<B>(materials.columns[4].values).push_back(present ? 1 : 0);
|
|
std::get<D>(materials.columns[5].values).push_back(rho);
|
|
}
|
|
plan.tables.push_back(std::move(materials));
|
|
SolidTable sections{"/model/solid/sections",
|
|
domain.SolidSections().Size(),
|
|
{{"internal_section_id", 1, U{}},
|
|
{"source_file", 1, S{}},
|
|
{"source_line", 1, U{}},
|
|
{"source_elset", 1, S{}},
|
|
{"material_internal_id", 1, U{}}}};
|
|
for (std::size_t i = 0; i < domain.SolidSections().Size(); ++i) {
|
|
const auto& section = domain.SolidSections()[i];
|
|
std::get<U>(sections.columns[0].values).push_back(i);
|
|
std::get<S>(sections.columns[1].values)
|
|
.push_back(section.Location().file.generic_u8string());
|
|
std::get<U>(sections.columns[2].values).push_back(section.Location().line);
|
|
std::get<S>(sections.columns[3].values).push_back(section.Name());
|
|
std::get<U>(sections.columns[4].values).push_back(section.MaterialIndex());
|
|
}
|
|
plan.tables.push_back(std::move(sections));
|
|
SolidTable points{"/model/solid_integration_points",
|
|
8 * domain.Elements().Size(),
|
|
{{"internal_element_id", 1, U{}},
|
|
{"point_id", 1, B{}},
|
|
{"natural_coordinates", 3, D{}},
|
|
{"reference_coordinates", 3, D{}}}};
|
|
ElementFactory factory;
|
|
for (std::size_t i = 0; i < domain.Elements().Size(); ++i) {
|
|
auto element = factory.Create(domain.Elements()[i], domain);
|
|
Check(element.HasValue(), "Solid factory reference failed.");
|
|
auto hex = factory.BindSolidTrial(*element.Value());
|
|
Check(hex != nullptr, "Solid kernel identity failed.");
|
|
auto response = hex->EvaluateLinear(Vector{24});
|
|
Check(response.HasValue(), "Solid reference recovery failed.");
|
|
for (const auto& point : response.Value().points) {
|
|
std::get<U>(points.columns[0].values).push_back(i);
|
|
std::get<B>(points.columns[1].values)
|
|
.push_back(static_cast<std::uint8_t>(point.integration_point));
|
|
auto& natural = std::get<D>(points.columns[2].values);
|
|
natural.insert(natural.end(), point.natural_coordinates.begin(),
|
|
point.natural_coordinates.end());
|
|
auto& position = std::get<D>(points.columns[3].values);
|
|
position.insert(position.end(), point.reference_coordinates.begin(),
|
|
point.reference_coordinates.end());
|
|
}
|
|
}
|
|
plan.tables.push_back(std::move(points));
|
|
plan.mask.assign(dofs.FullDofCount(), 0);
|
|
for (const auto index : dofs.ConstrainedDofs()) plan.mask[index] = 1;
|
|
}
|
|
void Diagnostics(SolidPlan& plan, std::vector<Diagnostic> diagnostics) {
|
|
SortDiagnostics(diagnostics);
|
|
SolidTable table{"/diagnostics",
|
|
diagnostics.size(),
|
|
{{"severity", 1, S{}},
|
|
{"code", 1, S{}},
|
|
{"file", 1, S{}},
|
|
{"line", 1, U{}},
|
|
{"keyword", 1, S{}},
|
|
{"entity_identity", 1, S{}},
|
|
{"message", 1, S{}}}};
|
|
for (const auto& d : diagnostics) {
|
|
std::get<S>(table.columns[0].values)
|
|
.push_back(d.severity == Severity::kWarning ? "warning" : "error");
|
|
std::get<S>(table.columns[1].values).push_back(d.code);
|
|
std::get<S>(table.columns[2].values)
|
|
.push_back(d.location.file.generic_u8string());
|
|
std::get<U>(table.columns[3].values).push_back(d.location.line);
|
|
std::get<S>(table.columns[4].values).push_back(d.keyword);
|
|
std::get<S>(table.columns[5].values).push_back(d.entity_identity);
|
|
std::get<S>(table.columns[6].values).push_back(d.message);
|
|
}
|
|
plan.tables.push_back(std::move(table));
|
|
}
|
|
} // namespace
|
|
|
|
Hdf5Handle SolidColumnType(const SolidColumn& column, bool native) {
|
|
Hdf5Handle result;
|
|
if (std::holds_alternative<S>(column.values))
|
|
result = MakeUtf8StringType();
|
|
else {
|
|
hid_t type = std::holds_alternative<U>(column.values)
|
|
? (native ? H5T_NATIVE_UINT64 : H5T_STD_U64LE)
|
|
: std::holds_alternative<B>(column.values)
|
|
? (native ? H5T_NATIVE_UINT8 : H5T_STD_U8LE)
|
|
: (native ? H5T_NATIVE_DOUBLE : H5T_IEEE_F64LE);
|
|
result = Hdf5Handle{
|
|
RequireHdf5Id(H5Tcopy(type), "Solid column type failed."), H5Tclose};
|
|
}
|
|
if (column.width > 1) {
|
|
const hsize_t width = column.width;
|
|
result = Hdf5Handle{RequireHdf5Id(H5Tarray_create2(result.Get(), 1, &width),
|
|
"Solid array type failed."),
|
|
H5Tclose};
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Result<SolidPlan> BuildSolidPlan(const Domain& domain, SolidStateView view,
|
|
const std::vector<Diagnostic>& diagnostics) {
|
|
try {
|
|
if (std::holds_alternative<
|
|
std::reference_wrapper<const SolidDynamicAnalysisState>>(view))
|
|
Check(math_internal::ArithmeticEnvironmentSupported(),
|
|
"Solid RN64 serialization requires supported arithmetic "
|
|
"environment.");
|
|
Check(domain.IsSolid() && domain.Steps().Size() == 1,
|
|
"Solid output requires exactly one Solid step.");
|
|
auto model = AnalysisModel::Create(domain);
|
|
Check(model.HasValue(), "Solid output model failed.");
|
|
auto dofs = DofManager::Create(model.Value());
|
|
Check(dofs.HasValue(), "Solid output DOF partition failed.");
|
|
SolidPlan plan;
|
|
const bool dynamic = std::holds_alternative<
|
|
std::reference_wrapper<const SolidDynamicAnalysisState>>(view);
|
|
const bool frequency = std::holds_alternative<
|
|
std::reference_wrapper<const SolidFrequencyState>>(view);
|
|
const bool nonlinear = domain.Steps()[0].UsesNonlinearGeometry();
|
|
Check(dynamic == (domain.Dynamic() != nullptr) &&
|
|
frequency == domain.Steps()[0].IsFrequency(),
|
|
"Solid output procedure/state mismatch.");
|
|
plan.metadata = {
|
|
{"feature_id", "hex8-structural-analysis"},
|
|
{"analysis_procedure", dynamic ? (nonlinear ? "hht-nonlinear-dynamics"
|
|
: "hht-linear-dynamics")
|
|
: frequency ? "linear-frequency"
|
|
: nonlinear ? "nonlinear-static-full-newton"
|
|
: "linear-static"},
|
|
{"element_formulation", "FESA-Hex8"},
|
|
{"integration_rule", "gauss-2x2x2"},
|
|
{"mass_formulation", "lumped-reference"},
|
|
{"source_input_identity", SourceInputIdentity(domain)},
|
|
{"source_step_name", domain.Steps()[0].Name()},
|
|
{"unit_system_label", "user-consistent-unspecified"},
|
|
{"coordinate_convention",
|
|
"global-cartesian; reference-strain; current-cauchy-stress"},
|
|
{"component_order", "node-major; UX,UY,UZ"},
|
|
{"solver_version", std::string(SolverVersion())}};
|
|
Model(plan, domain, dofs.Value());
|
|
Diagnostics(plan, diagnostics);
|
|
if (const auto* ref =
|
|
std::get_if<std::reference_wrapper<const SolidStaticState>>(
|
|
&view)) {
|
|
const auto& state = ref->get();
|
|
auto validator = SolidStaticState::Create(domain, dofs.Value());
|
|
Check(validator.HasValue(), "Static output validator creation failed.");
|
|
Check(!state.AcceptedFrames().empty(), "Static output history is empty.");
|
|
SolidTable accepted{"/steps/Step-1/accepted_frames",
|
|
state.AcceptedFrames().size(),
|
|
{{"frame_index", 1, U{}},
|
|
{"increment_index", 1, U{}},
|
|
{"load_factor", 1, D{}},
|
|
{"iteration_count", 1, U{}},
|
|
{"is_factor_one", 1, B{}}}};
|
|
for (const auto& frame : state.AcceptedFrames()) {
|
|
Check(validator.Value().CommitAcceptedFrame(frame).IsOk(),
|
|
"Static accepted frame is invalid.");
|
|
FrameData(plan, domain, frame.frame_index, frame.increment_index,
|
|
frame.load_factor, false, frame.displacement, frame.reaction,
|
|
frame.residual, frame.solid_results,
|
|
frame.physical_strain_energy);
|
|
std::get<U>(accepted.columns[0].values).push_back(frame.frame_index);
|
|
std::get<U>(accepted.columns[1].values)
|
|
.push_back(frame.increment_index);
|
|
std::get<D>(accepted.columns[2].values).push_back(frame.load_factor);
|
|
std::get<U>(accepted.columns[3].values)
|
|
.push_back(frame.iteration_count);
|
|
std::get<B>(accepted.columns[4].values)
|
|
.push_back(frame.is_factor_one ? 1 : 0);
|
|
}
|
|
Check(state.AcceptedFrames().back().is_factor_one,
|
|
"Static output is incomplete.");
|
|
if (nonlinear) plan.tables.push_back(std::move(accepted));
|
|
} else if (const auto* dynamic_ref = std::get_if<
|
|
std::reference_wrapper<const SolidDynamicAnalysisState>>(
|
|
&view)) {
|
|
Check(math_internal::ArithmeticEnvironmentSupported(),
|
|
"Solid RN64 serialization requires supported arithmetic "
|
|
"environment.");
|
|
const auto& state = dynamic_ref->get();
|
|
auto validator = SolidDynamicAnalysisState::Create(domain, dofs.Value());
|
|
Check(validator.HasValue(), "Dynamic output validator creation failed.");
|
|
Check(state.AcceptedFrames().size() ==
|
|
domain.Dynamic()->increment_count + 1,
|
|
"Dynamic output history is incomplete.");
|
|
SolidTable accepted{"/steps/Step-1/accepted_frames",
|
|
state.AcceptedFrames().size(),
|
|
{{"frame_index", 1, U{}},
|
|
{"increment_index", 1, U{}},
|
|
{"time", 1, D{}},
|
|
{"iteration_count", 1, U{}},
|
|
{"is_initial", 1, B{}}}};
|
|
for (const auto& frame : state.AcceptedFrames()) {
|
|
Check(validator.Value().CommitAcceptedFrame(frame).IsOk(),
|
|
"Full-pair dynamic accepted frame is invalid.");
|
|
FrameData(plan, domain, frame.frame_index, frame.increment_index,
|
|
frame.time, true, frame.displacement, frame.reaction,
|
|
frame.residual, frame.solid_results, frame.strain_energy);
|
|
const std::string root =
|
|
"/steps/Step-1/frames/" + std::to_string(frame.frame_index);
|
|
const auto add = [&](SolidData data) {
|
|
data.integers = {{"frame_index", frame.frame_index},
|
|
{"increment_index", frame.increment_index}};
|
|
data.doubles = {{"time", frame.time}};
|
|
plan.datasets.push_back(std::move(data));
|
|
};
|
|
add(Data(root + "/nodal/velocity", {domain.Nodes().size(), 3},
|
|
CopyVectorValues(frame.velocity), "V1,V2,V3", "length/time", "nodal"));
|
|
auto a = Data(root + "/nodal/acceleration", {domain.Nodes().size(), 3},
|
|
CopyVectorValues(frame.acceleration), "A1,A2,A3", "length/time^2",
|
|
"nodal");
|
|
a.strings["acceleration_kind"] = "physical";
|
|
add(std::move(a));
|
|
a = Data(root + "/nodal/algorithmic_acceleration",
|
|
{domain.Nodes().size(), 3},
|
|
CopyVectorValues(frame.algorithmic_acceleration), "A1,A2,A3",
|
|
"length/time^2", "nodal");
|
|
a.strings["acceleration_kind"] = "algorithmic";
|
|
add(std::move(a));
|
|
for (const auto& quantity :
|
|
std::vector<std::tuple<const char*, double, const char*>>{
|
|
{"kinetic_energy", frame.kinetic_energy, "0.5*v^T*M*v"},
|
|
{"external_work", frame.external_work,
|
|
"sum(0.5*(F_old+F_new)*delta_u)"},
|
|
{"energy_balance_error", frame.energy_balance_error,
|
|
"T+U-T0-U0-Wext"}}) {
|
|
auto data = Data(root + "/global/" + std::get<0>(quantity), {},
|
|
D{std::get<1>(quantity)}, "scalar", "force*length",
|
|
"global");
|
|
data.strings["definition"] = std::get<2>(quantity);
|
|
add(std::move(data));
|
|
}
|
|
add(Data(root + "/global/linear_momentum", {3},
|
|
D(frame.linear_momentum.begin(), frame.linear_momentum.end()),
|
|
"P1,P2,P3", "mass*length/time", "global"));
|
|
auto angular = Data(
|
|
root + "/global/angular_momentum", {3},
|
|
D(frame.angular_momentum.begin(), frame.angular_momentum.end()),
|
|
"L1,L2,L3", "mass*length^2/time", "global");
|
|
angular.strings["origin"] = "global0";
|
|
add(std::move(angular));
|
|
std::get<U>(accepted.columns[0].values).push_back(frame.frame_index);
|
|
std::get<U>(accepted.columns[1].values)
|
|
.push_back(frame.increment_index);
|
|
std::get<D>(accepted.columns[2].values).push_back(frame.time);
|
|
std::get<U>(accepted.columns[3].values)
|
|
.push_back(frame.iteration_count);
|
|
std::get<B>(accepted.columns[4].values)
|
|
.push_back(frame.is_initial ? 1 : 0);
|
|
}
|
|
plan.tables.push_back(std::move(accepted));
|
|
} else {
|
|
const auto& state =
|
|
std::get<std::reference_wrapper<const SolidFrequencyState>>(view)
|
|
.get();
|
|
Check(domain.Frequency()->requested_mode_count > 0,
|
|
"Modal request is invalid.");
|
|
const std::size_t count =
|
|
static_cast<std::size_t>(domain.Frequency()->requested_mode_count);
|
|
Check(state.full_dof_count == dofs.Value().FullDofCount() &&
|
|
state.free_dof_count == dofs.Value().FreeDofs().size() &&
|
|
state.constraint_mask == plan.mask,
|
|
"Modal DOF inventory is invalid.");
|
|
Check(state.prescribed_displacement.size() == plan.mask.size(),
|
|
"Modal prescribed shape is invalid.");
|
|
for (const auto value : state.prescribed_displacement)
|
|
Check(value == 0, "Modal prescribed value is invalid.");
|
|
Check(state.modes.size() == count && state.vectors.Rows() == count &&
|
|
state.vectors.Columns() == plan.mask.size(),
|
|
"Modal output shape is invalid.");
|
|
Check(std::isfinite(state.classification_scale) &&
|
|
state.classification_scale > 0 &&
|
|
std::isfinite(state.mass_lower_bound) &&
|
|
state.mass_lower_bound > 0,
|
|
"Modal certification scale is invalid.");
|
|
Check(std::isfinite(state.eta_gram) && state.eta_gram >= 0 &&
|
|
state.eta_gram <= 1e-10 && std::isfinite(state.max_eta_orth) &&
|
|
state.max_eta_orth >= 0 && state.max_eta_orth <= 1e-10,
|
|
"Modal Gram evidence is invalid.");
|
|
Check(state.eigenpair_checks.size() == state.backend.eigenvalues.size() &&
|
|
state.backend.column_ids.size() ==
|
|
state.eigenpair_checks.size() &&
|
|
state.eigenpair_checks.size() >= count &&
|
|
state.eigenpair_checks.size() <= state.free_dof_count,
|
|
"Modal backend verification inventory is invalid.");
|
|
std::size_t expected_cluster = 1;
|
|
SolidTable modes{"/steps/Step-1/eigen/modes",
|
|
count,
|
|
{{"mode_id", 1, U{}},
|
|
{"eigenvalue", 1, D{}},
|
|
{"classification", 1, B{}},
|
|
{"cluster_id", 1, U{}}}};
|
|
SolidTable frequencies{"/steps/Step-1/eigen/frequencies",
|
|
0,
|
|
{{"mode_id", 1, U{}}, {"frequency", 1, D{}}}};
|
|
D vectors;
|
|
for (std::size_t i = 0; i < count; ++i) {
|
|
const auto& mode = state.modes[i];
|
|
Check(mode.mode_id == i + 1 && mode.cluster_id > 0 &&
|
|
std::isfinite(mode.eigenvalue) &&
|
|
mode.eigenvalue / state.classification_scale >= -1e-9 &&
|
|
(i == 0 || mode.eigenvalue >= state.modes[i - 1].eigenvalue),
|
|
"Modal identity/order is invalid.");
|
|
if (i > 0 && (mode.eigenvalue - state.modes[i - 1].eigenvalue) /
|
|
state.classification_scale >
|
|
1e-8)
|
|
++expected_cluster;
|
|
Check(mode.cluster_id == expected_cluster &&
|
|
mode.eigenvalue == state.eigenpair_checks[i].eigenvalue,
|
|
"Modal cluster or selected-pair identity is invalid.");
|
|
const bool near =
|
|
std::abs(mode.eigenvalue) / state.classification_scale <= 1e-9;
|
|
Check(mode.classification == (near ? 0 : 1),
|
|
"Modal classification is invalid.");
|
|
Check(mode.frequency.has_value() == (mode.eigenvalue >= 0),
|
|
"Modal frequency presence is invalid.");
|
|
if (mode.frequency) {
|
|
Check(*mode.frequency ==
|
|
std::sqrt(mode.eigenvalue) / (2 * std::acos(-1.0)),
|
|
"Modal frequency is invalid.");
|
|
++frequencies.rows;
|
|
std::get<U>(frequencies.columns[0].values).push_back(mode.mode_id);
|
|
std::get<D>(frequencies.columns[1].values).push_back(*mode.frequency);
|
|
}
|
|
std::get<U>(modes.columns[0].values).push_back(mode.mode_id);
|
|
std::get<D>(modes.columns[1].values).push_back(mode.eigenvalue);
|
|
std::get<B>(modes.columns[2].values).push_back(mode.classification);
|
|
std::get<U>(modes.columns[3].values).push_back(mode.cluster_id);
|
|
for (std::size_t j = 0; j < plan.mask.size(); ++j) {
|
|
Check(std::isfinite(state.vectors(i, j)) &&
|
|
(!plan.mask[j] || state.vectors(i, j) == 0),
|
|
"Modal vector is invalid.");
|
|
vectors.push_back(state.vectors(i, j));
|
|
}
|
|
}
|
|
modes.strings = {{"component_names", "eigenvalue"},
|
|
{"unit_dimensions", "1/time^2"},
|
|
{"location", "global"},
|
|
{"coordinate_system", "global-cartesian"}};
|
|
frequencies.strings = {{"component_names", "frequency"},
|
|
{"unit_dimensions", "1/time"},
|
|
{"location", "global"},
|
|
{"coordinate_system", "global-cartesian"}};
|
|
plan.tables.push_back(std::move(modes));
|
|
plan.tables.push_back(std::move(frequencies));
|
|
auto data =
|
|
Data("/steps/Step-1/eigen/vectors", {count, domain.Nodes().size(), 3},
|
|
std::move(vectors), "UX,UY,UZ", "mass-normalized", "nodal");
|
|
data.strings["normalization"] = "phi^T*M*phi=1";
|
|
plan.datasets.push_back(std::move(data));
|
|
SolidTable pairs{"/steps/Step-1/eigen/verification/pairs",
|
|
state.eigenpair_checks.size(),
|
|
{{"sorted_rank", 1, U{}},
|
|
{"solver_column", 1, U{}},
|
|
{"eigenvalue", 1, D{}},
|
|
{"modal_mass", 1, D{}},
|
|
{"rayleigh_quotient", 1, D{}},
|
|
{"eta_r", 1, D{}},
|
|
{"eta_norm", 1, D{}},
|
|
{"eta_energy", 1, D{}}}};
|
|
|
|
std::set<std::size_t> solver_columns;
|
|
for (std::size_t i = 0; i < state.eigenpair_checks.size(); ++i) {
|
|
Check(state.backend.column_ids[i] < state.eigenpair_checks.size() &&
|
|
solver_columns.insert(state.backend.column_ids[i]).second,
|
|
"Modal backend column inventory is invalid.");
|
|
const auto& pair = state.eigenpair_checks[i];
|
|
const double normalized = pair.eigenvalue / state.classification_scale;
|
|
Check(std::isfinite(pair.eigenvalue) && std::isfinite(normalized),
|
|
"Backend eigenvalue or normalized eigenvalue is nonfinite.");
|
|
Check(normalized >= -1e-9,
|
|
"Significant negative backend eigenvalue cannot be published.");
|
|
Check(i == 0 ||
|
|
pair.eigenvalue >= state.eigenpair_checks[i - 1].eigenvalue,
|
|
"Backend eigenvalues are not sorted.");
|
|
|
|
Check(pair.sorted_rank == i + 1 &&
|
|
pair.solver_column == state.backend.column_ids[i] &&
|
|
pair.eigenvalue == state.backend.eigenvalues[i],
|
|
"Modal pair identity is invalid.");
|
|
Check(std::isfinite(pair.modal_mass) && pair.modal_mass > 0 &&
|
|
std::abs(pair.modal_mass - 1) <= 1e-10,
|
|
"Modal mass evidence is invalid.");
|
|
for (const double eta : {pair.eta_r, pair.eta_norm, pair.eta_energy})
|
|
Check(std::isfinite(eta) && eta >= 0 && eta <= 1e-10,
|
|
"Modal pair gate is invalid.");
|
|
std::get<U>(pairs.columns[0].values).push_back(pair.sorted_rank);
|
|
std::get<U>(pairs.columns[1].values).push_back(pair.solver_column);
|
|
const std::array<double, 6> values{{pair.eigenvalue, pair.modal_mass,
|
|
pair.rayleigh_quotient, pair.eta_r,
|
|
pair.eta_norm, pair.eta_energy}};
|
|
for (std::size_t j = 0; j < 6; ++j)
|
|
std::get<D>(pairs.columns[j + 2].values).push_back(values[j]);
|
|
}
|
|
plan.tables.push_back(std::move(pairs));
|
|
plan.datasets.push_back(Data("/steps/Step-1/eigen/verification/eta_gram",
|
|
{}, D{state.eta_gram}, "scalar",
|
|
"dimensionless", "global"));
|
|
plan.datasets.push_back(
|
|
Data("/steps/Step-1/eigen/verification/max_eta_orth", {},
|
|
D{state.max_eta_orth}, "scalar", "dimensionless", "global"));
|
|
}
|
|
for (const auto& table : plan.tables)
|
|
for (const auto& column : table.columns)
|
|
std::visit(
|
|
[&](const auto& values) {
|
|
Check(values.size() == table.rows * column.width,
|
|
"Solid column shape is invalid.");
|
|
using T = typename std::decay_t<decltype(values)>::value_type;
|
|
for (const auto& value : values) {
|
|
if constexpr (std::is_same_v<T, double>)
|
|
Check(std::isfinite(value),
|
|
"Solid numeric column is nonfinite.");
|
|
if constexpr (std::is_same_v<T, std::string>)
|
|
Check(IsValidUtf8(value) &&
|
|
value.find('\0') == std::string::npos,
|
|
"Solid string column is invalid UTF8.");
|
|
}
|
|
},
|
|
column.values);
|
|
for (const auto& data : plan.datasets) {
|
|
std::size_t size = 1;
|
|
for (const auto width : data.dimensions) {
|
|
Check(SizeProductFits(size, width, size),
|
|
"Solid dataset shape overflow.");
|
|
}
|
|
Check(size == data.values.size(), "Solid dataset shape is invalid.");
|
|
for (const auto value : data.values)
|
|
Check(std::isfinite(value), "Solid dataset value is nonfinite.");
|
|
}
|
|
for (const auto& item : plan.metadata)
|
|
Check(IsValidUtf8(item.second) &&
|
|
item.second.find('\0') == std::string::npos,
|
|
"Solid metadata UTF8 is invalid.");
|
|
return Result<SolidPlan>::Success(std::move(plan));
|
|
} catch (const std::exception& error) {
|
|
return Result<SolidPlan>::Failure(
|
|
OutputFailure("invalid-solid-output", error.what()));
|
|
}
|
|
}
|
|
|
|
Status WriteSolidFile(const std::filesystem::path& output, const Domain& domain,
|
|
SolidStateView view,
|
|
const std::vector<Diagnostic>& diagnostics,
|
|
const SolidFileHooks& hooks) {
|
|
const auto plan = BuildSolidPlan(domain, view, diagnostics);
|
|
if (!plan.HasValue()) return plan.GetStatus();
|
|
try {
|
|
Hdf5ErrorSilencer silence;
|
|
const auto candidate = MakeCandidatePath(output);
|
|
CandidateFileGuard guard(candidate);
|
|
Hdf5Handle file{
|
|
RequireHdf5Id(H5Fcreate(candidate.string().c_str(), H5F_ACC_EXCL,
|
|
H5P_DEFAULT, H5P_DEFAULT),
|
|
"Solid candidate create failed."),
|
|
hooks.candidate_close};
|
|
if (hooks.before_write) hooks.before_write(file.Get());
|
|
if (std::holds_alternative<
|
|
std::reference_wrapper<const SolidDynamicAnalysisState>>(view))
|
|
Check(math_internal::ArithmeticEnvironmentSupported(),
|
|
"Solid RN64 serialization arithmetic environment changed.");
|
|
{
|
|
auto group = CreateGroup(file.Get(), "/metadata");
|
|
WriteUint64Attribute(group.Get(), "schema_version", 1);
|
|
for (const auto& item : plan.Value().metadata)
|
|
WriteStringAttribute(group.Get(), item.first.c_str(), item.second);
|
|
}
|
|
(void)CreateGroup(file.Get(), "/model");
|
|
WriteNodes(file.Get(), domain);
|
|
for (const auto& table : plan.Value().tables)
|
|
if (table.path != "/model/nodes" && table.path != "/diagnostics")
|
|
Table(file.Get(), table);
|
|
WriteDiagnostics(file.Get(), diagnostics);
|
|
{
|
|
const std::vector<hsize_t> dimensions{domain.Nodes().size(), 3};
|
|
auto space = CreateDatasetSpace(dimensions);
|
|
Hdf5Handle dataset{
|
|
RequireHdf5Id(H5Dcreate2(file.Get(), "/model/nodal_constraint_mask",
|
|
H5T_STD_U8LE, space.Get(), H5P_DEFAULT,
|
|
H5P_DEFAULT, H5P_DEFAULT),
|
|
"Solid mask create failed."),
|
|
H5Dclose};
|
|
RequireHdf5(H5Dwrite(dataset.Get(), H5T_NATIVE_UINT8, H5S_ALL, H5S_ALL,
|
|
H5P_DEFAULT, plan.Value().mask.data()),
|
|
"Solid mask write failed.");
|
|
WriteStringAttribute(dataset.Get(), "component_names", "UX,UY,UZ");
|
|
}
|
|
for (const auto& data : plan.Value().datasets) {
|
|
Parent(file.Get(), data.path);
|
|
auto dataset = WriteDoubleValues(file.Get(), data.path, data.dimensions,
|
|
data.values.data(), data.values.size());
|
|
for (const auto& item : data.strings)
|
|
WriteStringAttribute(dataset.Get(), item.first.c_str(), item.second);
|
|
for (const auto& item : data.integers)
|
|
WriteUint64Attribute(dataset.Get(), item.first.c_str(), item.second);
|
|
for (const auto& item : data.doubles)
|
|
WriteDoubleAttribute(dataset.Get(), item.first.c_str(), item.second);
|
|
}
|
|
RequireHdf5(H5Fflush(file.Get(), H5F_SCOPE_GLOBAL),
|
|
"Solid candidate flush failed.");
|
|
RequireHdf5(file.CloseChecked(), "Solid candidate close failed.");
|
|
if (hooks.before_self_check) hooks.before_self_check(candidate);
|
|
const Status check =
|
|
SelfCheckSolidFile(candidate, plan.Value(), hooks.reader_close);
|
|
if (!check.IsOk()) return check;
|
|
if (hooks.before_finalize) hooks.before_finalize(candidate);
|
|
if (std::holds_alternative<
|
|
std::reference_wrapper<const SolidDynamicAnalysisState>>(view))
|
|
Check(math_internal::ArithmeticEnvironmentSupported(),
|
|
"Solid RN64 publication arithmetic environment changed.");
|
|
const Status finalized =
|
|
AtomicFinalizeValidatedCandidate(candidate, output, check);
|
|
if (finalized.IsOk()) guard.Release();
|
|
return finalized;
|
|
} catch (const std::exception& error) {
|
|
return OutputFailure("solid-output-failure", error.what());
|
|
}
|
|
}
|
|
} // namespace fesa::hdf5_internal
|
|
|
|
namespace fesa {
|
|
Status SolidHdf5ResultsWriter::Write(
|
|
const std::filesystem::path& path, const Domain& domain,
|
|
const SolidStaticState& state, const std::vector<Diagnostic>& diagnostics) {
|
|
return hdf5_internal::WriteSolidFile(path, domain, std::cref(state),
|
|
diagnostics);
|
|
}
|
|
Status SolidHdf5ResultsWriter::Write(
|
|
const std::filesystem::path& path, const Domain& domain,
|
|
const SolidFrequencyState& state,
|
|
const std::vector<Diagnostic>& diagnostics) {
|
|
return hdf5_internal::WriteSolidFile(path, domain, std::cref(state),
|
|
diagnostics);
|
|
}
|
|
Status SolidHdf5ResultsWriter::Write(
|
|
const std::filesystem::path& path, const Domain& domain,
|
|
const SolidDynamicAnalysisState& state,
|
|
const std::vector<Diagnostic>& diagnostics) {
|
|
return hdf5_internal::WriteSolidFile(path, domain, std::cref(state),
|
|
diagnostics);
|
|
}
|
|
} // namespace fesa
|