baram2584/FESADev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(cpp-object-oriented-modular-refactoring): step 4 - model-element-google-style

Browse Source
This commit is contained in:
KOKO\Mimi
2026-08-16 05:37:40 +09:00
parent 34ab8b5bf1
commit 8bc0ea2f8e
46 changed files with 5184 additions and 5323 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/fesa/io/hdf5/hdf5_results_writer.cpp
+123 -123
View File
@@ -231,11 +231,11 @@ struct WriterModelData {
};
bool isShellDomain(const Domain& domain) noexcept {
return !domain.shellElements().empty();
return !domain.ShellElements().empty();
}
const char* shellSourceTypeName(const ShellSourceElementType type) {
return type == ShellSourceElementType::s4 ? "S4" : "S4R";
return type == ShellSourceElementType::kS4 ? "S4" : "S4R";
}
bool isOrthonormalRightHanded(
@@ -266,14 +266,14 @@ bool isOrthonormalRightHanded(
bool computeLocalAxes(
const Domain& domain, const EulerBeam3DDefinition& element, AxisSet& axes) {
if (element.nodeIndices[0U] >= domain.nodes().size() ||
element.nodeIndices[1U] >= domain.nodes().size() ||
element.sectionIndex >= domain.sections().size()) {
if (element.node_indices[0U] >= domain.Nodes().size() ||
element.node_indices[1U] >= domain.Nodes().size() ||
element.section_index >= domain.Sections().size()) {
return false;
}
const auto& first = domain.nodes()[element.nodeIndices[0U]].coordinates;
const auto& second = domain.nodes()[element.nodeIndices[1U]].coordinates;
const auto& guide = domain.sections()[element.sectionIndex].firstAxis;
const auto& first = domain.Nodes()[element.node_indices[0U]].coordinates;
const auto& second = domain.Nodes()[element.node_indices[1U]].coordinates;
const auto& guide = domain.Sections()[element.section_index].first_axis;
const std::array<double, 3> delta = {
second[0U] - first[0U],
second[1U] - first[1U],
@@ -319,48 +319,48 @@ bool sizeProductFits(
Status validateShellWriterInput(
const Domain& domain, const AnalysisState& state) {
if (!domain.elements().empty()) {
if (!domain.Elements().empty()) {
return outputFailure(
"invalid-result-identity",
"Schema v0 does not combine B33 and FESA-MITC4 element inventories.");
}
for (const auto& material : domain.materials()) {
for (const auto& material : domain.Materials()) {
if (material.name.empty() || !isValidUtf8(material.name) ||
!std::isfinite(material.youngsModulus) ||
!std::isfinite(material.poissonRatio) ||
!(material.youngsModulus > 0.0)) {
!std::isfinite(material.youngs_modulus) ||
!std::isfinite(material.poisson_ratio) ||
!(material.youngs_modulus > 0.0)) {
return outputFailure(
"invalid-result-identity",
"Every shell material requires a UTF-8 name and finite constitutive data.");
}
}
for (const auto& section : domain.shellSections()) {
for (const auto& section : domain.ShellSections()) {
if (section.name.empty() || !isValidUtf8(section.name) ||
section.materialIndex >= domain.materials().size() ||
section.material_index >= domain.Materials().size() ||
!std::isfinite(section.thickness) || !(section.thickness > 0.0)) {
return outputFailure(
"invalid-result-identity",
"Every shell section requires stable material identity and positive finite thickness.");
}
}
for (const auto& element : domain.shellElements()) {
if ((element.sourceType != ShellSourceElementType::s4 &&
element.sourceType != ShellSourceElementType::s4r) ||
element.sourceId.source_label <= 0 ||
element.sourceId.source_label_text.empty() ||
!isValidUtf8(element.sourceId.instance_name) ||
!isValidUtf8(element.sourceId.source_label_text) ||
element.materialIndex >= domain.materials().size() ||
element.sectionIndex >= domain.shellSections().size() ||
domain.shellSections()[element.sectionIndex].materialIndex !=
element.materialIndex) {
for (const auto& element : domain.ShellElements()) {
if ((element.source_type != ShellSourceElementType::kS4 &&
element.source_type != ShellSourceElementType::kS4r) ||
element.source_id.source_label <= 0 ||
element.source_id.source_label_text.empty() ||
!isValidUtf8(element.source_id.instance_name) ||
!isValidUtf8(element.source_id.source_label_text) ||
element.material_index >= domain.Materials().size() ||
element.section_index >= domain.ShellSections().size() ||
domain.ShellSections()[element.section_index].material_index !=
element.material_index) {
return outputFailure(
"invalid-result-identity",
"Every shell element requires stable source, material, and section identity.");
}
std::array<EntityIndex, kShellNodeCount> sortedNodes = element.nodeIndices;
std::array<EntityIndex, kShellNodeCount> sortedNodes = element.node_indices;
std::sort(sortedNodes.begin(), sortedNodes.end());
if (sortedNodes.back() >= domain.nodes().size() ||
if (sortedNodes.back() >= domain.Nodes().size() ||
std::adjacent_find(sortedNodes.begin(), sortedNodes.end()) !=
sortedNodes.end()) {
return outputFailure(
@@ -368,18 +368,18 @@ Status validateShellWriterInput(
"Every shell element requires four distinct valid node identities.");
}
}
if (domain.shellNodeInitialFrames().size() != domain.nodes().size()) {
if (domain.ShellNodeInitialFrames().size() != domain.Nodes().size()) {
return outputFailure(
"invalid-result-identity",
"Shell output requires one initial director/frame per source-ordered node.");
}
for (std::size_t node = 0U;
node < domain.shellNodeInitialFrames().size();
node < domain.ShellNodeInitialFrames().size();
++node) {
const auto& source = domain.shellNodeInitialFrames()[node];
const auto& source = domain.ShellNodeInitialFrames()[node];
const std::array<std::array<double, 3>, 3> frame{
source.tangentA, source.tangentB, source.director};
if (source.nodeIndex != node || !isOrthonormalRightHanded(frame)) {
source.tangent_a, source.tangent_b, source.director};
if (source.node_index != node || !isOrthonormalRightHanded(frame)) {
return outputFailure(
"invalid-result-identity",
"Shell initial frames must be finite, orthonormal, right-handed, and node ordered.");
@@ -388,7 +388,7 @@ Status validateShellWriterInput(
std::size_t expectedRows = 0U;
if (!sizeProductFits(
domain.shellElements().size(), kShellLocationCount, expectedRows) ||
domain.ShellElements().size(), kShellLocationCount, expectedRows) ||
state.shellResults().size() != expectedRows) {
return outputFailure(
"invalid-result-rows",
@@ -477,7 +477,7 @@ Status validateWriterInput(
}
std::size_t fullDofCount = 0U;
if (!sizeProductFits(domain.nodes().size(), kDofsPerNode, fullDofCount)) {
if (!sizeProductFits(domain.Nodes().size(), kDofsPerNode, fullDofCount)) {
return outputFailure(
"invalid-result-state", "The nodal result shape overflows size_t.");
}
@@ -502,17 +502,17 @@ Status validateWriterInput(
}
}
if (domain.sourcePath().empty() || domain.sourceContentIdentity().empty() ||
!isValidUtf8(domain.sourceContentIdentity())) {
if (domain.SourcePath().empty() || domain.SourceContentIdentity().empty() ||
!isValidUtf8(domain.SourceContentIdentity())) {
return outputFailure(
"invalid-result-identity",
"Source path and UTF-8 content identity are required.");
}
for (const Node& node : domain.nodes()) {
if (node.sourceId.source_label <= 0 ||
node.sourceId.source_label_text.empty() ||
!isValidUtf8(node.sourceId.instance_name) ||
!isValidUtf8(node.sourceId.source_label_text) ||
for (const Node& node : domain.Nodes()) {
if (node.source_id.source_label <= 0 ||
node.source_id.source_label_text.empty() ||
!isValidUtf8(node.source_id.instance_name) ||
!isValidUtf8(node.source_id.source_label_text) ||
!isFinite(node.coordinates)) {
return outputFailure(
"invalid-result-identity",
@@ -521,15 +521,15 @@ Status validateWriterInput(
}
modelData.beamLocalAxes.clear();
modelData.beamLocalAxes.reserve(domain.elements().size());
for (const EulerBeam3DDefinition& element : domain.elements()) {
modelData.beamLocalAxes.reserve(domain.Elements().size());
for (const EulerBeam3DDefinition& element : domain.Elements()) {
AxisSet axes{};
if (element.sourceId.source_label <= 0 ||
element.sourceId.source_label_text.empty() ||
!isValidUtf8(element.sourceId.instance_name) ||
!isValidUtf8(element.sourceId.source_label_text) ||
element.nodeIndices[0U] == element.nodeIndices[1U] ||
element.materialIndex >= domain.materials().size() ||
if (element.source_id.source_label <= 0 ||
element.source_id.source_label_text.empty() ||
!isValidUtf8(element.source_id.instance_name) ||
!isValidUtf8(element.source_id.source_label_text) ||
element.node_indices[0U] == element.node_indices[1U] ||
element.material_index >= domain.Materials().size() ||
!computeLocalAxes(domain, element, axes)) {
return outputFailure(
"invalid-result-identity",
@@ -540,8 +540,8 @@ Status validateWriterInput(
std::size_t endpointCount = 0U;
std::size_t gaussCount = 0U;
if (!sizeProductFits(domain.elements().size(), kEndpointCount, endpointCount) ||
!sizeProductFits(domain.elements().size(), kGaussPointCount, gaussCount) ||
if (!sizeProductFits(domain.Elements().size(), kEndpointCount, endpointCount) ||
!sizeProductFits(domain.Elements().size(), kGaussPointCount, gaussCount) ||
state.endpointResults().size() != endpointCount ||
state.gaussResults().size() != gaussCount) {
return outputFailure(
@@ -555,11 +555,11 @@ Status validateWriterInput(
static_cast<EntityIndex>(rowIndex / kEndpointCount);
const int expectedEndpoint = static_cast<int>(rowIndex % kEndpointCount);
const EndpointResultRow& row = state.endpointResults()[rowIndex];
const auto& element = domain.elements()[expectedElement];
const auto& element = domain.Elements()[expectedElement];
const auto& expectedNode =
domain.nodes()[element.nodeIndices[static_cast<std::size_t>(expectedEndpoint)]];
domain.Nodes()[element.node_indices[static_cast<std::size_t>(expectedEndpoint)]];
if (row.element != expectedElement || row.endpoint != expectedEndpoint ||
!sameIdentity(row.node, expectedNode.sourceId) ||
!sameIdentity(row.node, expectedNode.source_id) ||
!isFinite(row.endAction) || !isFinite(row.sectionResultant)) {
return outputFailure(
"invalid-result-rows",
@@ -586,11 +586,11 @@ Status validateWriterInput(
std::size_t stressIndex = 0U;
for (std::size_t elementIndex = 0U;
elementIndex < domain.elements().size();
elementIndex < domain.Elements().size();
++elementIndex) {
const auto& element = domain.elements()[elementIndex];
const auto& element = domain.Elements()[elementIndex];
const auto& sectionPoints =
domain.sections()[element.sectionIndex].sectionPoints;
domain.Sections()[element.section_index].section_points;
for (std::size_t gauss = 0U; gauss < kGaussPointCount; ++gauss) {
const std::size_t count = sectionPoints.empty() ? 1U : sectionPoints.size();
for (std::size_t point = 0U; point < count; ++point) {
@@ -681,8 +681,8 @@ std::string normalizedPathString(const std::filesystem::path& path) {
}
std::string sourceInputIdentity(const Domain& domain) {
return "path=" + normalizedPathString(domain.sourcePath()) +
";content_identity=" + domain.sourceContentIdentity();
return "path=" + normalizedPathString(domain.SourcePath()) +
";content_identity=" + domain.SourceContentIdentity();
}
Hdf5Handle makeUtf8StringType() {
@@ -982,13 +982,13 @@ void writeMetadata(const hid_t file, const Domain& domain) {
void writeNodes(const hid_t file, const Domain& domain) {
std::vector<NodeWriteRow> rows;
rows.reserve(domain.nodes().size());
for (std::size_t index = 0U; index < domain.nodes().size(); ++index) {
const Node& node = domain.nodes()[index];
rows.reserve(domain.Nodes().size());
for (std::size_t index = 0U; index < domain.Nodes().size(); ++index) {
const Node& node = domain.Nodes()[index];
rows.push_back({
static_cast<std::uint64_t>(index),
node.sourceId.instance_name.c_str(),
node.sourceId.source_label_text.c_str(),
node.source_id.instance_name.c_str(),
node.source_id.source_label_text.c_str(),
{node.coordinates[0U], node.coordinates[1U], node.coordinates[2U]}});
}
@@ -1057,15 +1057,15 @@ void writeNodes(const hid_t file, const Domain& domain) {
void writeBeamElements(
const hid_t file, const Domain& domain, const std::vector<AxisSet>& axes) {
std::vector<ElementWriteRow> rows;
rows.reserve(domain.elements().size());
for (std::size_t index = 0U; index < domain.elements().size(); ++index) {
const auto& element = domain.elements()[index];
rows.reserve(domain.Elements().size());
for (std::size_t index = 0U; index < domain.Elements().size(); ++index) {
const auto& element = domain.Elements()[index];
ElementWriteRow row{
static_cast<std::uint64_t>(index),
element.sourceId.instance_name.c_str(),
element.sourceId.source_label_text.c_str(),
{static_cast<std::uint64_t>(element.nodeIndices[0U]),
static_cast<std::uint64_t>(element.nodeIndices[1U])},
element.source_id.instance_name.c_str(),
element.source_id.source_label_text.c_str(),
{static_cast<std::uint64_t>(element.node_indices[0U]),
static_cast<std::uint64_t>(element.node_indices[1U])},
{}};
std::copy(axes[index].begin(), axes[index].end(), row.localAxes);
rows.push_back(row);
@@ -1141,21 +1141,21 @@ void writeBeamElements(
void writeShellElements(const hid_t file, const Domain& domain) {
std::vector<ShellElementWriteRow> rows;
rows.reserve(domain.shellElements().size());
for (std::size_t index = 0U; index < domain.shellElements().size(); ++index) {
const auto& element = domain.shellElements()[index];
rows.reserve(domain.ShellElements().size());
for (std::size_t index = 0U; index < domain.ShellElements().size(); ++index) {
const auto& element = domain.ShellElements()[index];
rows.push_back({
static_cast<std::uint64_t>(index),
element.sourceId.instance_name.c_str(),
element.sourceId.source_label_text.c_str(),
shellSourceTypeName(element.sourceType),
element.source_id.instance_name.c_str(),
element.source_id.source_label_text.c_str(),
shellSourceTypeName(element.source_type),
kMitc4InternalFormulation.data(),
{static_cast<std::uint64_t>(element.nodeIndices[0U]),
static_cast<std::uint64_t>(element.nodeIndices[1U]),
static_cast<std::uint64_t>(element.nodeIndices[2U]),
static_cast<std::uint64_t>(element.nodeIndices[3U])},
static_cast<std::uint64_t>(element.sectionIndex),
static_cast<std::uint64_t>(element.materialIndex)});
{static_cast<std::uint64_t>(element.node_indices[0U]),
static_cast<std::uint64_t>(element.node_indices[1U]),
static_cast<std::uint64_t>(element.node_indices[2U]),
static_cast<std::uint64_t>(element.node_indices[3U])},
static_cast<std::uint64_t>(element.section_index),
static_cast<std::uint64_t>(element.material_index)});
}
auto stringType = makeUtf8StringType();
@@ -1226,14 +1226,14 @@ void writeShellElements(const hid_t file, const Domain& domain) {
void writeShellMaterials(const hid_t file, const Domain& domain) {
std::vector<ShellMaterialWriteRow> rows;
rows.reserve(domain.materials().size());
for (std::size_t index = 0U; index < domain.materials().size(); ++index) {
const auto& material = domain.materials()[index];
rows.reserve(domain.Materials().size());
for (std::size_t index = 0U; index < domain.Materials().size(); ++index) {
const auto& material = domain.Materials()[index];
rows.push_back({
static_cast<std::uint64_t>(index),
material.name.c_str(),
material.youngsModulus,
material.poissonRatio});
material.youngs_modulus,
material.poisson_ratio});
}
auto stringType = makeUtf8StringType();
Hdf5Handle fileType{
@@ -1276,20 +1276,20 @@ void writeShellMaterials(const hid_t file, const Domain& domain) {
void writeShellSections(const hid_t file, const Domain& domain) {
std::vector<std::string> sourceFiles;
sourceFiles.reserve(domain.shellSections().size());
for (const auto& section : domain.shellSections()) {
sourceFiles.reserve(domain.ShellSections().size());
for (const auto& section : domain.ShellSections()) {
sourceFiles.push_back(normalizedPathString(section.location.file));
}
std::vector<ShellSectionWriteRow> rows;
rows.reserve(domain.shellSections().size());
for (std::size_t index = 0U; index < domain.shellSections().size(); ++index) {
const auto& section = domain.shellSections()[index];
rows.reserve(domain.ShellSections().size());
for (std::size_t index = 0U; index < domain.ShellSections().size(); ++index) {
const auto& section = domain.ShellSections()[index];
rows.push_back({
static_cast<std::uint64_t>(index),
sourceFiles[index].c_str(),
static_cast<std::uint64_t>(section.location.line),
section.name.c_str(),
static_cast<std::uint64_t>(section.materialIndex),
static_cast<std::uint64_t>(section.material_index),
section.thickness});
}
auto stringType = makeUtf8StringType();
@@ -1343,24 +1343,24 @@ void writeShellSections(const hid_t file, const Domain& domain) {
void writeShellModelData(
const hid_t file, const Domain& domain, const WriterModelData& modelData) {
std::vector<double> directors;
directors.reserve(domain.nodes().size() * 3U);
directors.reserve(domain.Nodes().size() * 3U);
std::vector<double> frames;
frames.reserve(domain.nodes().size() * 9U);
for (const auto& frame : domain.shellNodeInitialFrames()) {
frames.reserve(domain.Nodes().size() * 9U);
for (const auto& frame : domain.ShellNodeInitialFrames()) {
directors.insert(
directors.end(), frame.director.begin(), frame.director.end());
frames.insert(frames.end(), frame.tangentA.begin(), frame.tangentA.end());
frames.insert(frames.end(), frame.tangentB.begin(), frame.tangentB.end());
frames.insert(frames.end(), frame.tangent_a.begin(), frame.tangent_a.end());
frames.insert(frames.end(), frame.tangent_b.begin(), frame.tangent_b.end());
frames.insert(frames.end(), frame.director.begin(), frame.director.end());
}
writeModelDoubleDataset(
file, "/model/shell/nodal_director",
{static_cast<hsize_t>(domain.nodes().size()), 3U},
{static_cast<hsize_t>(domain.Nodes().size()), 3U},
directors.data(), directors.size(), "D1,D2,D3", "1,1,1",
"global-cartesian", "nodal");
writeModelDoubleDataset(
file, "/model/shell/nodal_frame",
{static_cast<hsize_t>(domain.nodes().size()), 3U, 3U},
{static_cast<hsize_t>(domain.Nodes().size()), 3U, 3U},
frames.data(), frames.size(), "X,Y,Z", "1,1,1",
"global-cartesian", "nodal-frame");
{
@@ -1375,7 +1375,7 @@ void writeShellModelData(
writeShellMaterials(file, domain);
writeShellSections(file, domain);
const std::vector<hsize_t> nodalDimensions{
static_cast<hsize_t>(domain.nodes().size()), kDofsPerNode};
static_cast<hsize_t>(domain.Nodes().size()), kDofsPerNode};
writeUint8Dataset(
file, "/model/nodal_constraint_mask", nodalDimensions,
modelData.constraintMask.data(), modelData.constraintMask.size());
@@ -1573,7 +1573,7 @@ void writeShellResultDatasets(
}
const hsize_t elementCount =
static_cast<hsize_t>(domain.shellElements().size());
static_cast<hsize_t>(domain.ShellElements().size());
const std::string root = std::string{kStepRoot} + "/element/shell";
const std::string framePath = root + "/local_frame";
writeDoubleDataset(
@@ -1730,7 +1730,7 @@ void writeDiagnostics(
void writeResultDatasets(
const hid_t file, const Domain& domain, const AnalysisState& state) {
const std::vector<hsize_t> nodalDimensions = {
static_cast<hsize_t>(domain.nodes().size()), kDofsPerNode};
static_cast<hsize_t>(domain.Nodes().size()), kDofsPerNode};
writeDoubleDataset(
file,
std::string{kStepRoot} + "/nodal/displacement",
@@ -1758,11 +1758,11 @@ void writeResultDatasets(
}
const std::vector<hsize_t> endpointActionDimensions = {
static_cast<hsize_t>(domain.elements().size()),
static_cast<hsize_t>(domain.Elements().size()),
kEndpointCount,
kEndActionComponentCount};
const std::vector<hsize_t> generalizedDimensions = {
static_cast<hsize_t>(domain.elements().size()),
static_cast<hsize_t>(domain.Elements().size()),
kEndpointCount,
kGeneralizedComponentCount};
const auto endActions = flattenEndpointValues(state.endpointResults(), false);
@@ -2287,13 +2287,13 @@ void selfCheckFile(
requireCompoundDataset(
file.get(),
"/model/nodes",
static_cast<hsize_t>(domain.nodes().size()),
static_cast<hsize_t>(domain.Nodes().size()),
{"internal_node_id", "instance_name", "source_label", "coordinates"});
auto nodes = openDatasetForCheck(file.get(), "/model/nodes");
requireStringAttribute(nodes.get(), "coordinate_system", "global-cartesian");
requireStringAttribute(nodes.get(), "units_label", "length");
const std::vector<hsize_t> nodalDimensions = {
static_cast<hsize_t>(domain.nodes().size()), kDofsPerNode};
static_cast<hsize_t>(domain.Nodes().size()), kDofsPerNode};
requireDoubleDataset(
file.get(),
"/steps/Step-1/frames/0/nodal/displacement",
@@ -2315,7 +2315,7 @@ void selfCheckFile(
requireCompoundDataset(
file.get(),
"/model/elements",
static_cast<hsize_t>(domain.shellElements().size()),
static_cast<hsize_t>(domain.ShellElements().size()),
{"internal_element_id", "instance_name", "source_label",
"source_element_type", "internal_formulation", "node_internal_ids",
"shell_section_internal_id", "material_internal_id"});
@@ -2324,33 +2324,33 @@ void selfCheckFile(
requireCompoundDataset(
file.get(),
"/model/shell/materials",
static_cast<hsize_t>(domain.materials().size()),
static_cast<hsize_t>(domain.Materials().size()),
{"internal_material_id", "name", "E", "nu"});
requireCompoundDataset(
file.get(),
"/model/shell/sections",
static_cast<hsize_t>(domain.shellSections().size()),
static_cast<hsize_t>(domain.ShellSections().size()),
{"internal_section_id", "source_file", "source_line", "source_elset",
"material_internal_id", "thickness"});
std::vector<double> directors;
std::vector<double> frames;
directors.reserve(domain.nodes().size() * 3U);
frames.reserve(domain.nodes().size() * 9U);
for (const auto& frame : domain.shellNodeInitialFrames()) {
directors.reserve(domain.Nodes().size() * 3U);
frames.reserve(domain.Nodes().size() * 9U);
for (const auto& frame : domain.ShellNodeInitialFrames()) {
directors.insert(
directors.end(), frame.director.begin(), frame.director.end());
frames.insert(frames.end(), frame.tangentA.begin(), frame.tangentA.end());
frames.insert(frames.end(), frame.tangentB.begin(), frame.tangentB.end());
frames.insert(frames.end(), frame.tangent_a.begin(), frame.tangent_a.end());
frames.insert(frames.end(), frame.tangent_b.begin(), frame.tangent_b.end());
frames.insert(frames.end(), frame.director.begin(), frame.director.end());
}
requireModelDoubleDataset(
file.get(), "/model/shell/nodal_director",
{static_cast<hsize_t>(domain.nodes().size()), 3U},
{static_cast<hsize_t>(domain.Nodes().size()), 3U},
"D1,D2,D3", "1,1,1", "global-cartesian", "nodal", &directors);
requireModelDoubleDataset(
file.get(), "/model/shell/nodal_frame",
{static_cast<hsize_t>(domain.nodes().size()), 3U, 3U},
{static_cast<hsize_t>(domain.Nodes().size()), 3U, 3U},
"X,Y,Z", "1,1,1", "global-cartesian", "nodal-frame", &frames);
auto nodalFrame = openDatasetForCheck(
file.get(), "/model/shell/nodal_frame");
@@ -2383,7 +2383,7 @@ void selfCheckFile(
positions.get(), "position_names", "BOTTOM,MIDDLE,TOP");
const hsize_t elementCount =
static_cast<hsize_t>(domain.shellElements().size());
static_cast<hsize_t>(domain.ShellElements().size());
const std::string shellRoot = std::string{kStepRoot} + "/element/shell";
requireDoubleDataset(
file.get(), (shellRoot + "/local_frame").c_str(),
@@ -2459,18 +2459,18 @@ void selfCheckFile(
requireCompoundDataset(
file.get(),
"/model/elements",
static_cast<hsize_t>(domain.elements().size()),
static_cast<hsize_t>(domain.Elements().size()),
{"internal_element_id", "instance_name", "source_label",
"node_internal_ids", "local_axes"});
auto elements = openDatasetForCheck(file.get(), "/model/elements");
requireStringAttribute(
elements.get(), "formulation", "B33-3D-Euler-Bernoulli");
const std::vector<hsize_t> endDimensions = {
static_cast<hsize_t>(domain.elements().size()),
static_cast<hsize_t>(domain.Elements().size()),
kEndpointCount,
kEndActionComponentCount};
const std::vector<hsize_t> generalizedDimensions = {
static_cast<hsize_t>(domain.elements().size()),
static_cast<hsize_t>(domain.Elements().size()),
kGaussPointCount,
kGeneralizedComponentCount};
requireDoubleDataset(