KOKO\Mimi
1051 lines
45 KiB
C++
1051 lines
45 KiB
C++
#include <gtest/gtest.h>
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <atomic>
|
|
#include <cmath>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <limits>
|
|
#include <random>
|
|
#include <sstream>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "fesa/analysis/analysis_model.h"
|
|
#include "fesa/analysis/thermal_time_grid.h"
|
|
#include "fesa/fem/dof_manager.h"
|
|
#include "fesa/io/abaqus/domain_mapper.h"
|
|
#include "fesa/io/abaqus/input_reader.h"
|
|
|
|
namespace {
|
|
|
|
class TemporaryInput final {
|
|
public:
|
|
explicit TemporaryInput(const std::string& content) {
|
|
// Atomically claim a directory: separate CTest processes never share files.
|
|
do {
|
|
directory_ =
|
|
std::filesystem::temp_directory_path() /
|
|
("fesa-thermal-domain-" + std::to_string(std::random_device{}()) +
|
|
"-" + std::to_string(next_id_.fetch_add(1U)));
|
|
} while (!std::filesystem::create_directory(directory_));
|
|
path_ = directory_ / "model.inp";
|
|
std::ofstream output{path_, std::ios::binary | std::ios::trunc};
|
|
output << content;
|
|
if (!output) throw std::runtime_error{"Unable to write thermal fixture."};
|
|
}
|
|
~TemporaryInput() {
|
|
std::error_code error;
|
|
std::filesystem::remove(path_, error);
|
|
std::filesystem::remove(directory_, error);
|
|
}
|
|
const std::filesystem::path& Path() const noexcept { return path_; }
|
|
|
|
private:
|
|
static std::atomic<unsigned long> next_id_;
|
|
std::filesystem::path directory_;
|
|
std::filesystem::path path_;
|
|
};
|
|
|
|
std::atomic<unsigned long> TemporaryInput::next_id_{0U};
|
|
|
|
fesa::Result<fesa::Domain> MapText(const std::string& text) {
|
|
const TemporaryInput input{text};
|
|
const auto parsed = fesa::AbaqusInputReader{}.Read(input.Path());
|
|
if (!parsed.HasValue())
|
|
return fesa::Result<fesa::Domain>::Failure(parsed.GetStatus());
|
|
return fesa::AbaqusDomainMapper{}.Map(parsed.Value());
|
|
}
|
|
|
|
std::string ThermalDeck() {
|
|
return R"inp(*Part, name=P
|
|
*Node
|
|
1, 0., 0., 0.
|
|
2, 1., 0., 0.
|
|
3, 1., 1., 0.
|
|
4, 0., 1., 0.
|
|
*Element, type=DS4
|
|
1, 1, 2, 3, 4
|
|
*Elset, elset=E
|
|
1
|
|
*Shell Section, elset=E, material=M
|
|
.5, 5
|
|
*End Part
|
|
*Assembly, name=A
|
|
*Instance, name=I, part=P
|
|
*End Instance
|
|
*Nset, nset=Bottom, instance=I
|
|
1
|
|
2
|
|
*End Assembly
|
|
*Material, name=M
|
|
*Density
|
|
7850.,
|
|
*Conductivity
|
|
54.,
|
|
*Specific Heat
|
|
460.,
|
|
*Initial Conditions, type=TEMPERATURE
|
|
Bottom, 20.
|
|
*Boundary
|
|
Bottom, 11, 11
|
|
*Step, name=Heat, inc=100
|
|
*Heat Transfer
|
|
1., 100.
|
|
*Boundary
|
|
Bottom, 15, 15, 30.
|
|
*Cflux
|
|
Bottom, 11, -2.
|
|
*Cflux
|
|
Bottom, 11, -3.
|
|
*End Step
|
|
)inp";
|
|
}
|
|
|
|
std::string Replace(std::string deck, const std::string& from,
|
|
const std::string& to) {
|
|
const auto position = deck.find(from);
|
|
if (position == std::string::npos)
|
|
throw std::runtime_error{"Missing fixture token."};
|
|
deck.replace(position, from.size(), to);
|
|
return deck;
|
|
}
|
|
|
|
std::size_t LineOf(const std::string& deck, const std::string& token) {
|
|
const auto position = deck.find(token);
|
|
if (position == std::string::npos)
|
|
throw std::runtime_error{"Missing source token."};
|
|
return 1U + static_cast<std::size_t>(
|
|
std::count(deck.begin(), deck.begin() + position, '\n'));
|
|
}
|
|
|
|
void ExpectRejected(const std::string& deck, const std::string& keyword = "") {
|
|
const TemporaryInput input{deck};
|
|
const auto parsed = fesa::AbaqusInputReader{}.Read(input.Path());
|
|
ASSERT_TRUE(parsed.HasValue());
|
|
const auto result = fesa::AbaqusDomainMapper{}.Map(parsed.Value());
|
|
ASSERT_FALSE(result.HasValue());
|
|
ASSERT_FALSE(result.GetStatus().Diagnostics().empty());
|
|
const auto& diagnostic = result.GetStatus().Diagnostics().front();
|
|
EXPECT_EQ(diagnostic.severity, fesa::Severity::kError);
|
|
EXPECT_EQ(diagnostic.location.file, input.Path());
|
|
EXPECT_GT(diagnostic.location.line, 0U);
|
|
if (!keyword.empty()) EXPECT_EQ(diagnostic.keyword, keyword);
|
|
}
|
|
|
|
std::string Number(double value) {
|
|
std::ostringstream stream;
|
|
stream << std::setprecision(std::numeric_limits<double>::max_digits10)
|
|
<< value;
|
|
return stream.str();
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, MapsDs4MaterialsTargetsAndAdditiveFluxes) {
|
|
const auto result = MapText(ThermalDeck());
|
|
ASSERT_TRUE(result.HasValue())
|
|
<< (result.HasValue() ? ""
|
|
: result.GetStatus().Diagnostics().front().message);
|
|
const auto& domain = result.Value();
|
|
ASSERT_EQ(domain.ThermalElements().Size(), 1U);
|
|
ASSERT_EQ(domain.ThermalMaterials().Size(), 1U);
|
|
EXPECT_DOUBLE_EQ(domain.ThermalMaterials()[0U].Conductivity(), 54.0);
|
|
ASSERT_NE(domain.ThermalStep(), nullptr);
|
|
EXPECT_EQ(domain.ThermalStep()->name, "Heat");
|
|
EXPECT_EQ(domain.ThermalStep()->maximum_increments, 100U);
|
|
EXPECT_EQ(domain.ThermalModelBoundaries().size(), 2U);
|
|
EXPECT_EQ(domain.ThermalStep()->Boundaries().size(), 2U);
|
|
ASSERT_EQ(domain.ThermalStep()->Loads().size(), 4U);
|
|
EXPECT_DOUBLE_EQ(domain.ThermalStep()->Loads()[0U].power, -2.0);
|
|
EXPECT_DOUBLE_EQ(domain.ThermalStep()->Loads()[3U].power, -3.0);
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, RejectsInteriorAndConflictingThermalBoundaries) {
|
|
auto interior = ThermalDeck();
|
|
interior.replace(interior.find("Bottom, 11, 11\n"), 14U, "Bottom, 12, 12\n");
|
|
const auto invalid_dof = MapText(interior);
|
|
ASSERT_FALSE(invalid_dof.HasValue());
|
|
EXPECT_EQ(invalid_dof.GetStatus().Diagnostics()[0U].code, "invalid-dof");
|
|
|
|
auto conflicting = ThermalDeck();
|
|
conflicting.replace(conflicting.find("*Cflux"), 0U,
|
|
"*Boundary\nBottom, 15, 15, 99.\n");
|
|
const auto invalid_conflict = MapText(conflicting);
|
|
ASSERT_FALSE(invalid_conflict.HasValue());
|
|
EXPECT_EQ(invalid_conflict.GetStatus().Diagnostics()[0U].code,
|
|
"conflicting-boundary-condition");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping,
|
|
AcceptsSectionPointSpellingsAndRejectsUnsupportedForms) {
|
|
const std::vector<std::pair<std::string, bool>> cases{
|
|
{".5\n", true}, {".5, 5\n", true}, {".5, 05\n", true},
|
|
{".5, 4\n", false}, {".5, 6\n", false}, {".5, 5, 0.\n", false}};
|
|
for (const auto& test_case : cases) {
|
|
SCOPED_TRACE(test_case.first);
|
|
auto deck = ThermalDeck();
|
|
const auto start = deck.find(".5, 5\n");
|
|
deck.replace(start, std::string{".5, 5\n"}.size(), test_case.first);
|
|
EXPECT_EQ(MapText(deck).HasValue(), test_case.second);
|
|
}
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, RejectsThermalMaterialAndControlForms) {
|
|
struct Case {
|
|
std::string from;
|
|
std::string to;
|
|
};
|
|
const std::vector<Case> cases{
|
|
{"54.,\n", "54., 1.\n"},
|
|
{"460.,\n", "460.\n461.\n"},
|
|
{"7850.,\n", "-1.,\n"},
|
|
{"*Conductivity\n", "*Conductivity, dependencies=1\n"},
|
|
{"*Specific Heat\n460.,\n", ""},
|
|
{"*Specific Heat\n460.,\n", "*Specific Heat\n460.,\n*Elastic\n1., .3\n"},
|
|
{"*Heat Transfer\n1., 100.\n",
|
|
"*Heat Transfer, steady state\n1., 100.\n"},
|
|
{"*Heat Transfer\n1., 100.\n", "*Heat Transfer\n0., 100.\n"},
|
|
{"inc=100", "inc=99"},
|
|
{"*Step, name=Heat, inc=100", "*Step, name=Heat, nlgeom=YES, inc=100"},
|
|
{"*Step, name=Heat, inc=100", "*Step, name=Heat, perturbation, inc=100"}};
|
|
for (const auto& test_case : cases) {
|
|
SCOPED_TRACE(test_case.to);
|
|
auto deck = ThermalDeck();
|
|
const auto position = deck.find(test_case.from);
|
|
ASSERT_NE(position, std::string::npos);
|
|
deck.replace(position, test_case.from.size(), test_case.to);
|
|
EXPECT_FALSE(MapText(deck).HasValue());
|
|
}
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, RejectsThermalNoOpAndProcedureViolations) {
|
|
const std::vector<std::pair<std::string, std::string>> cases{
|
|
{"*Part, name=P",
|
|
"*Preprint, echo=NO, model=NO, history=NO\n*Part, name=P"},
|
|
{"1., 100.\n", "1., 100., , , ,\n"},
|
|
{"*Cflux", "*Static\n.1, 1., .1, 1.\n*Cflux"},
|
|
{"*End Step", "*Output, field\n*Node Output\nNT\n*End Step"}};
|
|
for (const auto& test_case : cases) {
|
|
auto deck = ThermalDeck();
|
|
const auto position = deck.find(test_case.first);
|
|
ASSERT_NE(position, std::string::npos);
|
|
deck.replace(position, test_case.first.size(), test_case.second);
|
|
EXPECT_FALSE(MapText(deck).HasValue());
|
|
}
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, AppliesSameDofStepOverrideAndDefaultValues) {
|
|
auto deck = ThermalDeck();
|
|
const auto first = deck.find("Bottom, 15, 15, 30.");
|
|
deck.replace(first, std::string{"Bottom, 15, 15, 30."}.size(),
|
|
"Bottom, 11, 11, 30.");
|
|
const auto result = MapText(deck);
|
|
ASSERT_TRUE(result.HasValue());
|
|
ASSERT_EQ(result.Value().ThermalModelBoundaries().size(), 2U);
|
|
ASSERT_EQ(result.Value().ThermalStep()->Boundaries().size(), 2U);
|
|
EXPECT_DOUBLE_EQ(result.Value().ThermalModelBoundaries()[0U].value, 0.0);
|
|
EXPECT_DOUBLE_EQ(result.Value().ThermalStep()->Boundaries()[0U].value, 30.0);
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, MapsApprovedShellThermalReference) {
|
|
auto path = std::filesystem::path{__FILE__}.parent_path();
|
|
for (int index = 0; index < 4; ++index) path = path.parent_path();
|
|
path /= "reference/shell-thermal/shell-thermal.inp";
|
|
const auto parsed = fesa::AbaqusInputReader{}.Read(path);
|
|
ASSERT_TRUE(parsed.HasValue());
|
|
const auto result = fesa::AbaqusDomainMapper{}.Map(parsed.Value());
|
|
ASSERT_TRUE(result.HasValue())
|
|
<< (result.HasValue() ? ""
|
|
: result.GetStatus().Diagnostics().front().message);
|
|
const auto& domain = result.Value();
|
|
ASSERT_EQ(domain.Nodes().size(), 729U);
|
|
ASSERT_EQ(domain.ThermalElements().Size(), 676U);
|
|
ASSERT_EQ(domain.ThermalMaterials().Size(), 1U);
|
|
ASSERT_EQ(domain.ThermalSections().size(), 1U);
|
|
ASSERT_NE(domain.ThermalStep(), nullptr);
|
|
const auto& step = *domain.ThermalStep();
|
|
EXPECT_EQ(step.name, "Step-1");
|
|
EXPECT_EQ(step.maximum_increments, 100000U);
|
|
EXPECT_EQ(step.nominal_increment, 1.);
|
|
EXPECT_EQ(step.time_period, 100.);
|
|
const auto grid = fesa::ThermalTimeGrid::Create(
|
|
step.time_period, step.nominal_increment, step.maximum_increments);
|
|
ASSERT_TRUE(grid.HasValue());
|
|
EXPECT_EQ(grid.Value().Count(), 100U);
|
|
EXPECT_EQ(grid.Value().Time(37U), 37.);
|
|
EXPECT_EQ(domain.ThermalMaterials()[0].Name(), "Material-1");
|
|
EXPECT_EQ(domain.ThermalMaterials()[0].Conductivity(), 54.);
|
|
EXPECT_EQ(domain.ThermalMaterials()[0].Density(), 7850.);
|
|
EXPECT_EQ(domain.ThermalMaterials()[0].SpecificHeat(), 460.);
|
|
EXPECT_EQ(domain.ThermalSections()[0].name, "Set-1");
|
|
EXPECT_EQ(domain.ThermalSections()[0].thickness, .5);
|
|
EXPECT_EQ(domain.ThermalSections()[0].location.file, path);
|
|
EXPECT_EQ(domain.ThermalSections()[0].location.line, 1421U);
|
|
for (std::size_t i = 0; i < domain.Nodes().size(); ++i) {
|
|
EXPECT_EQ(domain.Nodes()[i].source_id.instance_name, "Part-1-1");
|
|
EXPECT_EQ(domain.Nodes()[i].source_id.source_label,
|
|
static_cast<std::int64_t>(i + 1U));
|
|
}
|
|
for (std::size_t i = 0; i < domain.ThermalElements().Size(); ++i) {
|
|
EXPECT_EQ(domain.ThermalElements()[i].SourceId().instance_name, "Part-1-1");
|
|
EXPECT_EQ(domain.ThermalElements()[i].SourceId().source_label,
|
|
static_cast<std::int64_t>(i + 1U));
|
|
}
|
|
std::vector<std::int64_t> expected_boundary_labels{2, 5, 6, 7};
|
|
for (std::int64_t label = 58; label <= 105; ++label)
|
|
expected_boundary_labels.push_back(label);
|
|
for (std::int64_t label = 298; label <= 441; ++label)
|
|
expected_boundary_labels.push_back(label);
|
|
ASSERT_EQ(domain.ThermalModelBoundaries().size(),
|
|
expected_boundary_labels.size());
|
|
ASSERT_EQ(domain.ThermalModelBoundaries().size(), step.Boundaries().size());
|
|
for (std::size_t i = 0; i < step.Boundaries().size(); ++i) {
|
|
const auto& model_bc = domain.ThermalModelBoundaries()[i];
|
|
const auto& step_bc = step.Boundaries()[i];
|
|
EXPECT_EQ(model_bc.node_index, step_bc.node_index);
|
|
EXPECT_EQ(domain.Nodes()[model_bc.node_index].source_id.source_label,
|
|
expected_boundary_labels[i]);
|
|
EXPECT_EQ(model_bc.dof, 11);
|
|
EXPECT_EQ(step_bc.dof, 11);
|
|
EXPECT_EQ(model_bc.value, 0.);
|
|
EXPECT_EQ(step_bc.value, 1000.);
|
|
EXPECT_EQ(model_bc.location.file, path);
|
|
EXPECT_LT(model_bc.location.line, step_bc.location.line);
|
|
}
|
|
ASSERT_EQ(domain.ElementSurfaces().size(), 1U);
|
|
ASSERT_EQ(domain.ElementSurfaces()[0].facets.size(), 169U);
|
|
EXPECT_EQ(domain.ElementSurfaces()[0].facets.front().source_element_label,
|
|
170);
|
|
EXPECT_EQ(domain.ElementSurfaces()[0].facets.back().source_element_label,
|
|
338);
|
|
EXPECT_EQ(domain.ElementSurfaces()[0].facets[0].source_element_type, "DS4");
|
|
ASSERT_EQ(domain.Warnings().size(), 6U);
|
|
for (const auto& block : parsed.Value().blocks) {
|
|
if (block.canonical_name != "PREPRINT" &&
|
|
block.canonical_name != "PHYSICAL CONSTANTS" &&
|
|
block.canonical_name != "SURFACE" &&
|
|
block.canonical_name != "RESTART" && block.canonical_name != "OUTPUT")
|
|
continue;
|
|
EXPECT_EQ(std::count_if(domain.Warnings().begin(), domain.Warnings().end(),
|
|
[&](const auto& warning) {
|
|
return warning.location.file == path &&
|
|
warning.location.line ==
|
|
block.location.line &&
|
|
warning.keyword == block.canonical_name;
|
|
}),
|
|
1);
|
|
}
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, StrictOutputAndRestartNoOps) {
|
|
for (const std::string block :
|
|
{"*Output, field\n", "*Output, field, variable=ALL\n",
|
|
"*Output, field, variable=PRESELECT, frequency=0\n",
|
|
"*Output, history\n", "*Output, history, frequency=7\n",
|
|
"*Output, history, frequency=0, variable=PRESELECT\n",
|
|
"*Output, field, history, variable=PRESELECT\n",
|
|
"*Output, field=YES, variable=PRESELECT\n",
|
|
"*Output, field, variable=PRESELECT\nNT\n",
|
|
"*Output, history, frequency=0\nNT\n", "*Restart\n",
|
|
"*Restart, write\n", "*Restart, frequency=0\n",
|
|
"*Restart, write=YES, frequency=0\n", "*Restart, write, frequency=1\n",
|
|
"*Restart, write, frequency=0, overlay\n",
|
|
"*Restart, write, frequency=0\n0\n"}) {
|
|
SCOPED_TRACE(block);
|
|
ExpectRejected(Replace(ThermalDeck(), "*End Step", block + "*End Step"));
|
|
}
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, EveryAcceptedNoOpHasExactlyOneSourceWarning) {
|
|
const std::vector<std::pair<std::string, std::string>> blocks{
|
|
{"*Preprint, echo=NO, model=NO, history=NO, contact=NO\n", "PREPRINT"},
|
|
{"*Physical Constants, absolute zero=-273.15\n", "PHYSICAL CONSTANTS"},
|
|
{"*Surface, type=ELEMENT, name=S\nI.1, SPOS\n", "SURFACE"},
|
|
{"*Restart, write, frequency=0\n", "RESTART"},
|
|
{"*Output, field, variable=PRESELECT\n", "OUTPUT"},
|
|
{"*Output, history, frequency=0\n", "OUTPUT"}};
|
|
auto deck = ThermalDeck();
|
|
deck = blocks[0].first + deck;
|
|
deck = Replace(deck, "*Material", blocks[1].first + "*Material");
|
|
deck = Replace(deck, "*End Assembly", blocks[2].first + "*End Assembly");
|
|
for (std::size_t i = 3U; i < blocks.size(); ++i)
|
|
deck = Replace(deck, "*End Step", blocks[i].first + "*End Step");
|
|
const TemporaryInput input{deck};
|
|
const auto parsed = fesa::AbaqusInputReader{}.Read(input.Path());
|
|
ASSERT_TRUE(parsed.HasValue());
|
|
const auto result = fesa::AbaqusDomainMapper{}.Map(parsed.Value());
|
|
ASSERT_TRUE(result.HasValue());
|
|
const auto& warnings = result.Value().Warnings();
|
|
ASSERT_EQ(warnings.size(), blocks.size());
|
|
for (const auto& block : blocks) {
|
|
const auto line = LineOf(deck, block.first);
|
|
EXPECT_EQ(std::count_if(warnings.begin(), warnings.end(),
|
|
[&](const auto& w) {
|
|
return w.severity == fesa::Severity::kWarning &&
|
|
w.keyword == block.second &&
|
|
w.location.file == input.Path() &&
|
|
w.location.line == line;
|
|
}),
|
|
1);
|
|
}
|
|
EXPECT_DOUBLE_EQ(
|
|
result.Value().ThermalInitialConditions()[0].station_values[0], 20.);
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, SurfaceFacetsAreResolvedAndPreserved) {
|
|
for (const std::string side : {"SPOS", "SNEG"}) {
|
|
auto deck = Replace(
|
|
ThermalDeck(), "*End Assembly",
|
|
"*Elset, elset=Faces, instance=I\n1\n"
|
|
"*Surface, type=ELEMENT, name=Direct\nI.1, " +
|
|
side + "\n*Surface, type=ELEMENT, name=SetSurface\nFaces, " + side +
|
|
"\n*End Assembly");
|
|
const auto result = MapText(deck);
|
|
ASSERT_TRUE(result.HasValue());
|
|
const auto& surfaces = result.Value().ElementSurfaces();
|
|
ASSERT_EQ(surfaces.size(), 2U);
|
|
for (std::size_t i = 0; i < surfaces.size(); ++i) {
|
|
ASSERT_EQ(surfaces[i].facets.size(), 1U);
|
|
const auto& facet = surfaces[i].facets[0];
|
|
EXPECT_EQ(facet.element_index, 0U);
|
|
EXPECT_EQ(facet.source_element_label, 1);
|
|
EXPECT_EQ(facet.instance_name_raw, "I");
|
|
EXPECT_EQ(facet.part_name_raw, "P");
|
|
EXPECT_EQ(facet.source_element_type, "DS4");
|
|
EXPECT_EQ(facet.side, side == "SPOS" ? fesa::ShellSurfaceSide::kSpos
|
|
: fesa::ShellSurfaceSide::kSneg);
|
|
EXPECT_EQ(facet.member_kind, i == 0U ? fesa::SurfaceMemberKind::kDirect
|
|
: fesa::SurfaceMemberKind::kElset);
|
|
EXPECT_EQ(facet.first_member_location.line,
|
|
LineOf(deck, (i == 0U ? "I.1, " : "Faces, ") + side));
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, RejectsUnresolvedOrInvalidSurfaces) {
|
|
for (const std::string row :
|
|
{"Missing.1, SPOS", "I.99, SPOS", "Missing, SPOS", "E, SPOS",
|
|
"P.1, SPOS", "I.E, SPOS", "I.1, S1", "I.1", "I.1, SPOS, 1"}) {
|
|
SCOPED_TRACE(row);
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), "*End Assembly",
|
|
"*Surface, type=ELEMENT, name=S\n" + row + "\n*End Assembly"),
|
|
"SURFACE");
|
|
}
|
|
for (const std::string header :
|
|
{"*Surface, name=S", "*Surface, type=ELEMENT",
|
|
"*Surface, type=NODE, name=S",
|
|
"*Surface, type=ELEMENT, name=S, internal"}) {
|
|
ExpectRejected(Replace(ThermalDeck(), "*End Assembly",
|
|
header + "\nI.1, SPOS\n*End Assembly"),
|
|
"SURFACE");
|
|
}
|
|
ExpectRejected(Replace(ThermalDeck(), "*End Assembly",
|
|
"*Surface, type=ELEMENT, name=S\n*End Assembly"),
|
|
"SURFACE");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping,
|
|
PreprintAndPhysicalConstantsAreStrictAndSourceAware) {
|
|
for (const std::string block :
|
|
{"*Preprint\n", "*Preprint, echo=NO, model=NO, history=NO\n",
|
|
"*Preprint, echo=NO, model=NO, history=NO, contact=YES\n",
|
|
"*Preprint, echo=NO, model=NO, history=NO, contact\n",
|
|
"*Preprint, echo=NO, model=NO, history=NO, contact=NO, unknown=NO\n",
|
|
"*Preprint, echo=NO, model=NO, history=NO, contact=NO\ndata\n",
|
|
"*Physical Constants\n", "*Physical Constants, absolute zero=nan\n",
|
|
"*Physical Constants, absolute zero=inf\n",
|
|
"*Physical Constants, absolute zero=\n",
|
|
"*Physical Constants, absolute zero=-273.15, stefan boltzmann=1\n",
|
|
"*Physical Constants, absolute zero=-273.15\ndata\n"}) {
|
|
SCOPED_TRACE(block);
|
|
ExpectRejected(block + ThermalDeck());
|
|
}
|
|
auto structural = Replace(ThermalDeck(), "type=DS4", "type=S4");
|
|
structural =
|
|
Replace(structural,
|
|
"*Density\n7850.,\n*Conductivity\n54.,\n*Specific Heat\n460.,\n",
|
|
"*Elastic\n210000., .3\n");
|
|
structural = Replace(
|
|
structural, "*Initial Conditions, type=TEMPERATURE\nBottom, 20.\n", "");
|
|
structural = Replace(structural, "Bottom, 11, 11", "Bottom, 1, 1");
|
|
structural = Replace(structural, "*Heat Transfer\n1., 100.",
|
|
"*Static\n1., 1., 1., 1.");
|
|
structural = Replace(structural,
|
|
"*Boundary\nBottom, 15, 15, 30.\n*Cflux\nBottom, 11, "
|
|
"-2.\n*Cflux\nBottom, 11, -3.\n",
|
|
"");
|
|
const std::string block = "*Physical Constants, absolute zero=-273.15\n";
|
|
structural = block + structural;
|
|
const auto result = MapText(structural);
|
|
ASSERT_FALSE(result.HasValue());
|
|
EXPECT_EQ(result.GetStatus().Diagnostics()[0].keyword, "PHYSICAL CONSTANTS");
|
|
EXPECT_EQ(result.GetStatus().Diagnostics()[0].location.line, 1U);
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, RejectsChildOutputUnknownAndWrongNoOpScopes) {
|
|
const std::vector<std::string> blocks{
|
|
"*Preprint, echo=NO, model=NO, history=NO, contact=NO\n",
|
|
"*Physical Constants, absolute zero=-273.15\n",
|
|
"*Restart, write, frequency=0\n", "*Output, field, variable=PRESELECT\n",
|
|
"*Surface, type=ELEMENT, name=S\nI.1, SPOS\n"};
|
|
for (std::size_t i = 0; i < blocks.size(); ++i) {
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), "*End Part", blocks[i] + "*End Part"));
|
|
const auto target = i < 2U || i == 4U ? "*End Step" : "*Material";
|
|
ExpectRejected(Replace(ThermalDeck(), target, blocks[i] + target));
|
|
}
|
|
for (const std::string child :
|
|
{"NODE OUTPUT", "ELEMENT OUTPUT", "CONTACT OUTPUT", "ENERGY OUTPUT"}) {
|
|
ExpectRejected(Replace(ThermalDeck(), "*End Step",
|
|
"*Output, field, variable=PRESELECT\n*" + child +
|
|
"\n*End Step"),
|
|
child);
|
|
}
|
|
ExpectRejected(Replace(ThermalDeck(), "*End Step",
|
|
"*Unknown Thermal Keyword\n*End Step"));
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, MaterialConstantsAndSectionLinksAreStrict) {
|
|
for (const auto& property : std::vector<std::pair<std::string, std::string>>{
|
|
{"Density", "7850."},
|
|
{"Conductivity", "54."},
|
|
{"Specific Heat", "460."}}) {
|
|
const std::string original =
|
|
"*" + property.first + "\n" + property.second + ",\n";
|
|
for (const std::string tail : {"\n", ",\n"}) {
|
|
const auto result = MapText(
|
|
Replace(ThermalDeck(), original,
|
|
"*" + property.first + "\n" + property.second + tail));
|
|
ASSERT_TRUE(result.HasValue()) << property.first << tail;
|
|
}
|
|
for (const std::string value :
|
|
{"0", "-1", "nan", "inf", "1e400", "", "1, 20", "1,,", "1\n2"}) {
|
|
SCOPED_TRACE(property.first + ":" + value);
|
|
ExpectRejected(Replace(ThermalDeck(), original,
|
|
"*" + property.first + "\n" + value + "\n"));
|
|
}
|
|
for (const std::string option : {"dependencies=1", "type=ANISOTROPIC",
|
|
"type=ORTHOTROPIC", "unknown=1"})
|
|
ExpectRejected(Replace(ThermalDeck(), "*" + property.first + "\n",
|
|
"*" + property.first + ", " + option + "\n"));
|
|
ExpectRejected(Replace(ThermalDeck(), original, ""), "MATERIAL");
|
|
ExpectRejected(Replace(ThermalDeck(), original, original + original));
|
|
}
|
|
for (const std::string row :
|
|
{"0", "-1", "nan", "inf", ".5,", ".5, 5.0", ".5, 3", ".5,5,", ".5\n.5"})
|
|
ExpectRejected(Replace(ThermalDeck(), ".5, 5\n", row + "\n"),
|
|
"SHELL SECTION");
|
|
for (const std::string option :
|
|
{"offset=0", "offset=SPOS", "composite", "nodal thickness"})
|
|
ExpectRejected(Replace(ThermalDeck(), "*Shell Section, elset=E, material=M",
|
|
"*Shell Section, elset=E, material=M, " + option),
|
|
"SHELL SECTION");
|
|
ExpectRejected(Replace(ThermalDeck(), "material=M", "material=Missing"),
|
|
"SHELL SECTION");
|
|
ExpectRejected(Replace(ThermalDeck(), "*Shell Section, elset=E",
|
|
"*Shell Section, elset=Missing"),
|
|
"SHELL SECTION");
|
|
ExpectRejected(Replace(ThermalDeck(),
|
|
"*Shell Section, elset=E, material=M\n.5, 5\n", ""),
|
|
"ELEMENT");
|
|
ExpectRejected(Replace(ThermalDeck(), "*End Part",
|
|
"*Shell Section, elset=E, material=M\n.5\n*End Part"),
|
|
"SHELL SECTION");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, InitialTemperatureDefaultsAndOverlaps) {
|
|
const auto unspecified = MapText(
|
|
Replace(ThermalDeck(),
|
|
"*Initial Conditions, type=TEMPERATURE\nBottom, 20.\n", ""));
|
|
ASSERT_TRUE(unspecified.HasValue());
|
|
EXPECT_TRUE(unspecified.Value().ThermalInitialConditions().empty());
|
|
for (const std::string row : {"1, 20.", "Bottom, 20."}) {
|
|
const auto result = MapText(
|
|
Replace(ThermalDeck(), "Bottom, 20.\n", "Bottom, 20.\n" + row + "\n"));
|
|
ASSERT_TRUE(result.HasValue());
|
|
for (const auto& initial : result.Value().ThermalInitialConditions())
|
|
for (const auto temperature : initial.station_values)
|
|
EXPECT_DOUBLE_EQ(temperature, 20.);
|
|
}
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), "Bottom, 20.\n", "Bottom, 20.\n1, -20.\n"),
|
|
"INITIAL CONDITIONS");
|
|
for (const std::string row :
|
|
{"Missing, 20.", "99, 20.", "1", "1, 20., 30.", "1, nan", ", 20."})
|
|
ExpectRejected(Replace(ThermalDeck(), "Bottom, 20.\n", row + "\n"),
|
|
"INITIAL CONDITIONS");
|
|
for (const std::string header :
|
|
{"*Initial Conditions", "*Initial Conditions, type=STRESS",
|
|
"*Initial Conditions, type=TEMPERATURE, amplitude=A"})
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), "*Initial Conditions, type=TEMPERATURE", header),
|
|
"INITIAL CONDITIONS");
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), "*End Step",
|
|
"*Initial Conditions, type=TEMPERATURE\n1, 1\n*End Step"),
|
|
"INITIAL CONDITIONS");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, InactiveTargetsFailWithOriginalKeywordAndIdentity) {
|
|
const auto inactive = Replace(ThermalDeck(), "*Element, type=DS4",
|
|
"99, 2., 2., 0.\n*Element, type=DS4");
|
|
const auto accepted = MapText(inactive);
|
|
ASSERT_TRUE(accepted.HasValue());
|
|
EXPECT_EQ(accepted.Value().Nodes().size(), 5U);
|
|
const auto view = fesa::AnalysisModel::Create(accepted.Value());
|
|
ASSERT_TRUE(view.HasValue());
|
|
EXPECT_EQ(view.Value().ActiveThermalNodes().size(), 4U);
|
|
for (const auto& replacement :
|
|
std::vector<std::pair<std::string, std::string>>{
|
|
{"Bottom, 20.", "99, 20."},
|
|
{"Bottom, 11, 11", "99, 11, 11"},
|
|
{"Bottom, 15, 15, 30.", "99, 15, 15, 30."},
|
|
{"Bottom, 11, -2.", "99, 11, -2."}}) {
|
|
const auto deck = Replace(inactive, replacement.first, replacement.second);
|
|
const auto result = MapText(deck);
|
|
ASSERT_FALSE(result.HasValue());
|
|
const auto& diagnostic = result.GetStatus().Diagnostics()[0];
|
|
EXPECT_EQ(diagnostic.entity_identity, "99");
|
|
EXPECT_EQ(diagnostic.location.line, LineOf(deck, replacement.second));
|
|
EXPECT_NE(diagnostic.keyword, "THERMAL");
|
|
}
|
|
}
|
|
|
|
TEST(ThermalDomainMapping,
|
|
ModelBoundaryInheritanceAndStepOverrideReachDofManager) {
|
|
auto deck = Replace(ThermalDeck(), "Bottom, 11, 11\n",
|
|
"Bottom, 11, 11, 7.\n4, 15, 15\n1, 11, 11, 7.\n");
|
|
deck = Replace(deck, "Bottom, 15, 15, 30.",
|
|
"1, 11, 11, -30.\n1, 11, 11, -30.\n2, 15, 15");
|
|
const auto result = MapText(deck);
|
|
ASSERT_TRUE(result.HasValue());
|
|
const auto& domain = result.Value();
|
|
ASSERT_EQ(domain.ThermalModelBoundaries().size(), 4U);
|
|
ASSERT_EQ(domain.ThermalStep()->Boundaries().size(), 3U);
|
|
EXPECT_DOUBLE_EQ(domain.ThermalModelBoundaries()[0].value, 7.);
|
|
EXPECT_DOUBLE_EQ(domain.ThermalStep()->Boundaries()[0].value, -30.);
|
|
const auto model = fesa::AnalysisModel::Create(domain);
|
|
ASSERT_TRUE(model.HasValue());
|
|
const auto dofs = fesa::DofManager::CreateThermal(model.Value());
|
|
ASSERT_TRUE(dofs.HasValue());
|
|
const std::vector<std::size_t> expected_dofs{0U, 5U, 9U, 19U};
|
|
EXPECT_EQ(dofs.Value().ConstrainedDofs(), expected_dofs);
|
|
const std::array<double, 4> expected_values{-30., 7., 0., 0.};
|
|
for (std::size_t i = 0; i < expected_values.size(); ++i)
|
|
EXPECT_DOUBLE_EQ(dofs.Value().PrescribedValues()[i], expected_values[i]);
|
|
}
|
|
|
|
TEST(ThermalDomainMapping,
|
|
BoundariesRejectConflictsAndUnsupportedRowsAtBothLevels) {
|
|
for (const std::string original :
|
|
{"Bottom, 11, 11\n", "Bottom, 15, 15, 30.\n"}) {
|
|
const std::string equal = original.find("15") == std::string::npos
|
|
? "1, 11, 11, 0.\n"
|
|
: "1, 15, 15, 30.\n";
|
|
EXPECT_TRUE(
|
|
MapText(Replace(ThermalDeck(), original, original + equal)).HasValue());
|
|
const std::string conflict = original.find("15") == std::string::npos
|
|
? "1, 11, 11, 2.\n"
|
|
: "1, 15, 15, 2.\n";
|
|
ExpectRejected(Replace(ThermalDeck(), original, original + conflict),
|
|
"BOUNDARY");
|
|
for (const std::string row :
|
|
{"Bottom, 12, 12", "Bottom, 13, 13", "Bottom, 14, 14",
|
|
"Bottom, 11, 15", "Bottom, 11", "Bottom, 11, 11,",
|
|
"Bottom, 11, 11, 1, 2", "Bottom, 15, 15, inf", "Missing, 11, 11"})
|
|
ExpectRejected(Replace(ThermalDeck(), original, row + "\n"), "BOUNDARY");
|
|
for (const std::string option : {"OP=NEW", "AMPLITUDE=A"})
|
|
ExpectRejected(Replace(ThermalDeck(), "*Boundary\n" + original,
|
|
"*Boundary, " + option + "\n" + original),
|
|
"BOUNDARY");
|
|
}
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), "*End Part", "*Boundary\n1, 11, 11\n*End Part"),
|
|
"BOUNDARY");
|
|
ExpectRejected(Replace(ThermalDeck(), "*Heat Transfer",
|
|
"*Boundary\n1, 11, 11\n*Heat Transfer"),
|
|
"BOUNDARY");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping,
|
|
SignedFluxRetainsRowOrderDuplicatesAndConstrainedTargets) {
|
|
auto deck =
|
|
Replace(ThermalDeck(), "1\n2\n*End Assembly", "2, 1, 2\n*End Assembly");
|
|
deck = Replace(
|
|
deck, "*Cflux\nBottom, 11, -2.\n*Cflux\nBottom, 11, -3.",
|
|
"*Cflux\n2, 15, 9.\nBottom, 11, -2.\n1, 11, 3.\n*Cflux\n1, 11, 3.");
|
|
const auto result = MapText(deck);
|
|
ASSERT_TRUE(result.HasValue());
|
|
const auto& loads = result.Value().ThermalStep()->Loads();
|
|
ASSERT_EQ(loads.size(), 5U);
|
|
const std::array<unsigned, 5> nodes{1, 1, 0, 0, 0};
|
|
const std::array<int, 5> dofs{15, 11, 11, 11, 11};
|
|
const std::array<double, 5> powers{9., -2., -2., 3., 3.};
|
|
for (std::size_t i = 0; i < loads.size(); ++i) {
|
|
EXPECT_EQ(loads[i].node_index, nodes[i]);
|
|
EXPECT_EQ(loads[i].dof, dofs[i]);
|
|
EXPECT_DOUBLE_EQ(loads[i].power, powers[i]);
|
|
EXPECT_EQ(loads[i].source_order, i);
|
|
}
|
|
EXPECT_EQ(loads[1].location.line, loads[2].location.line);
|
|
EXPECT_LT(loads[3].location.line, loads[4].location.line);
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, FluxRejectsOptionsRowsAndWrongScopes) {
|
|
for (const std::string row :
|
|
{"Bottom, 12, 1", "Bottom, 13, 1", "Bottom, 14, 1", "Bottom, 11",
|
|
"Bottom, 11, 1,", "Bottom, 11, inf", "Bottom, 11, nan",
|
|
"Missing, 11, 1", ", 11, 1"})
|
|
ExpectRejected(Replace(ThermalDeck(), "Bottom, 11, -2.", row), "CFLUX");
|
|
for (const std::string option : {"OP=NEW", "AMPLITUDE=A", "unknown=1"})
|
|
ExpectRejected(Replace(ThermalDeck(), "*Cflux", "*Cflux, " + option),
|
|
"CFLUX");
|
|
for (const std::string target :
|
|
{"*Part", "*End Part", "*End Assembly", "*Step", "*Heat Transfer"})
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), target, "*Cflux\n1, 11, 1\n" + target), "CFLUX");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping,
|
|
TimeControlsUseSharedGridIncludingInputCellBoundaries) {
|
|
struct Case {
|
|
double increment;
|
|
double period;
|
|
unsigned count;
|
|
double last;
|
|
};
|
|
const double tiny = std::numeric_limits<double>::denorm_min();
|
|
const std::vector<Case> cases{
|
|
{1., 100., 100, 1.},
|
|
{3., 10., 4, 1.},
|
|
{3., 2., 1, 2.},
|
|
{2., 2., 1, 2.},
|
|
{.3, .9, 3, .3},
|
|
{.3, std::nextafter(.9, 1.), 4, 1.6653345369377348e-16},
|
|
{6 * tiny, 20 * tiny, 3, 6 * tiny},
|
|
{5 * tiny, 17 * tiny, 4, 2 * tiny}};
|
|
for (const auto& item : cases) {
|
|
SCOPED_TRACE(Number(item.increment) + ", " + Number(item.period));
|
|
auto deck = Replace(ThermalDeck(), "1., 100.",
|
|
Number(item.increment) + ", " + Number(item.period));
|
|
deck = Replace(deck, "inc=100", "inc=" + std::to_string(item.count));
|
|
const auto result = MapText(deck);
|
|
ASSERT_TRUE(result.HasValue());
|
|
const auto& step = *result.Value().ThermalStep();
|
|
EXPECT_EQ(step.nominal_increment, item.increment);
|
|
EXPECT_EQ(step.time_period, item.period);
|
|
const auto grid = fesa::ThermalTimeGrid::Create(
|
|
step.time_period, step.nominal_increment, step.maximum_increments);
|
|
ASSERT_TRUE(grid.HasValue());
|
|
EXPECT_EQ(grid.Value().Count(), item.count);
|
|
EXPECT_DOUBLE_EQ(grid.Value().Time(item.count), item.period);
|
|
EXPECT_EQ(grid.Value().Delta(item.count), item.last);
|
|
if (item.count > 1U)
|
|
ExpectRejected(Replace(deck, "inc=" + std::to_string(item.count),
|
|
"inc=" + std::to_string(item.count - 1U)),
|
|
"HEAT TRANSFER");
|
|
}
|
|
auto largest_grid = Replace(ThermalDeck(), "1., 100.", "1., 4294967295.");
|
|
largest_grid = Replace(largest_grid, "inc=100", "inc=4294967295");
|
|
const auto upper = MapText(largest_grid);
|
|
ASSERT_TRUE(upper.HasValue());
|
|
EXPECT_EQ(upper.Value().ThermalStep()->maximum_increments, 4294967295U);
|
|
ExpectRejected(Replace(largest_grid, "1., 4294967295.", "1., 4294967296."),
|
|
"HEAT TRANSFER");
|
|
const auto defaults =
|
|
MapText(Replace(ThermalDeck(), ", inc=100", ", nlgeom=NO"));
|
|
ASSERT_TRUE(defaults.HasValue());
|
|
EXPECT_EQ(defaults.Value().ThermalStep()->maximum_increments, 100U);
|
|
for (const std::string option : {"", ", end=PERIOD"}) {
|
|
for (int empty = 0; empty <= 3; ++empty) {
|
|
auto deck = Replace(
|
|
ThermalDeck(), "*Heat Transfer\n1., 100.",
|
|
"*Heat Transfer" + option + "\n1., 100." + std::string(empty, ','));
|
|
EXPECT_TRUE(MapText(deck).HasValue()) << deck;
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, RejectsInvalidTimeAndMixedProceduresInEitherOrder) {
|
|
for (const std::string row :
|
|
{"1, 100,,,,", "1, 100, 0", "1, 100,, 2", "1", "1,", "0, 1", "-1, 1",
|
|
"1, 0", "1, -1", "nan, 1", "1, inf", "1e-300, 1e300", "1, 100\n1, 100"})
|
|
ExpectRejected(Replace(ThermalDeck(), "1., 100.", row), "HEAT TRANSFER");
|
|
for (const std::string option :
|
|
{"steady state", "deltmx=1", "end=SS", "unknown=1"})
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), "*Heat Transfer", "*Heat Transfer, " + option),
|
|
"HEAT TRANSFER");
|
|
for (const std::string option :
|
|
{"inc=0", "inc=-1", "inc=4294967296", "inc=1.5", "inc="})
|
|
ExpectRejected(Replace(ThermalDeck(), "inc=100", option), "STEP");
|
|
for (const std::string procedure :
|
|
{"*Static\n1, 1, 1, 1\n", "*Frequency\n1\n",
|
|
"*Dynamic, direct\n1, 100\n", "*Heat Transfer\n1, 100\n"}) {
|
|
ExpectRejected(Replace(ThermalDeck(), "*Heat Transfer\n",
|
|
procedure + "*Heat Transfer\n"));
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), "1., 100.\n", "1., 100.\n" + procedure));
|
|
}
|
|
ExpectRejected(ThermalDeck() + "*Step\n*Heat Transfer\n1,1\n*End Step\n",
|
|
"STEP");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, ThermalMaterialAndSourceProvenanceArePreserved) {
|
|
const auto deck = Replace(
|
|
ThermalDeck(), "*Material, name=M",
|
|
"*Material, name=Unused\n*Density\n2\n*Conductivity\n3\n*Specific "
|
|
"Heat\n4\n*Material, name=M");
|
|
const TemporaryInput input{deck};
|
|
const auto parsed = fesa::AbaqusInputReader{}.Read(input.Path());
|
|
ASSERT_TRUE(parsed.HasValue());
|
|
const auto result = fesa::AbaqusDomainMapper{}.Map(parsed.Value());
|
|
ASSERT_TRUE(result.HasValue());
|
|
const auto& domain = result.Value();
|
|
ASSERT_EQ(domain.ThermalMaterials().Size(), 2U);
|
|
ASSERT_EQ(domain.ThermalSections().size(), 1U);
|
|
const auto& section = domain.ThermalSections()[0];
|
|
EXPECT_EQ(section.material_index, 1U);
|
|
EXPECT_EQ(section.name, "E");
|
|
EXPECT_EQ(section.source_id.source_label_text, "E");
|
|
EXPECT_EQ(section.location.file, input.Path());
|
|
EXPECT_EQ(section.location.line, LineOf(deck, "*Shell Section"));
|
|
EXPECT_DOUBLE_EQ(section.thickness, .5);
|
|
const auto& material = domain.ThermalMaterials()[section.material_index];
|
|
EXPECT_EQ(material.Name(), "M");
|
|
EXPECT_DOUBLE_EQ(material.Conductivity(), 54.);
|
|
EXPECT_DOUBLE_EQ(material.Density(), 7850.);
|
|
EXPECT_DOUBLE_EQ(material.SpecificHeat(), 460.);
|
|
EXPECT_EQ(material.Location().line, LineOf(deck, "*Material, name=M"));
|
|
EXPECT_EQ(domain.ThermalElements()[0].SourceId().instance_name, "I");
|
|
EXPECT_EQ(domain.ThermalElements()[0].SourceId().source_label, 1);
|
|
EXPECT_EQ(domain.ThermalStep()->name, "Heat");
|
|
EXPECT_EQ(domain.ThermalStep()->location.file, input.Path());
|
|
EXPECT_EQ(domain.ThermalStep()->location.line, LineOf(deck, "*Step"));
|
|
}
|
|
|
|
TEST(ThermalDomainMapping,
|
|
FiniteThermalScalarsPreserveSubnormalAndSignedValues) {
|
|
const double tiny = std::numeric_limits<double>::denorm_min();
|
|
const std::string text = Number(tiny);
|
|
for (const auto& item : std::vector<std::pair<std::string, std::string>>{
|
|
{"54.,", text},
|
|
{"7850.,", text},
|
|
{"460.,", text},
|
|
{".5, 5", text + ",5"},
|
|
{"Bottom, 20.", "Bottom, -" + text},
|
|
{"Bottom, 15, 15, 30.", "Bottom, 15, 15, -" + text},
|
|
{"Bottom, 11, -2.", "Bottom, 11, -" + text}}) {
|
|
SCOPED_TRACE(item.first);
|
|
const auto result =
|
|
MapText(Replace(ThermalDeck(), item.first, item.second));
|
|
ASSERT_TRUE(result.HasValue());
|
|
const auto& domain = result.Value();
|
|
if (item.first == "54.,")
|
|
EXPECT_EQ(domain.ThermalMaterials()[0].Conductivity(), tiny);
|
|
if (item.first == "7850.,")
|
|
EXPECT_EQ(domain.ThermalMaterials()[0].Density(), tiny);
|
|
if (item.first == "460.,")
|
|
EXPECT_EQ(domain.ThermalMaterials()[0].SpecificHeat(), tiny);
|
|
if (item.first == ".5, 5")
|
|
EXPECT_EQ(domain.ThermalSections()[0].thickness, tiny);
|
|
if (item.first == "Bottom, 20.")
|
|
EXPECT_EQ(domain.ThermalInitialConditions()[0].station_values[4], -tiny);
|
|
if (item.first == "Bottom, 15, 15, 30.")
|
|
EXPECT_EQ(domain.ThermalStep()->Boundaries()[0].value, -tiny);
|
|
if (item.first == "Bottom, 11, -2.")
|
|
EXPECT_EQ(domain.ThermalStep()->Loads()[0].power, -tiny);
|
|
}
|
|
for (const std::string value :
|
|
{"+2.5", "-0", "0", "-20.25", "1.7976931348623157e308"}) {
|
|
const auto result =
|
|
MapText(Replace(ThermalDeck(), "Bottom, 20.", "Bottom, " + value));
|
|
ASSERT_TRUE(result.HasValue());
|
|
}
|
|
for (const std::string value : {"1e-999", "1e999", "0x1p0", "+-1", "1D2"}) {
|
|
for (const std::string original :
|
|
{"54.,", "460.,", ".5, 5", "Bottom, 20.", "Bottom, 11, -2."}) {
|
|
const auto replacement =
|
|
original == "Bottom, 20."
|
|
? "Bottom, " + value
|
|
: (original == "Bottom, 11, -2." ? "Bottom, 11, " + value
|
|
: value);
|
|
ExpectRejected(Replace(ThermalDeck(), original, replacement));
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, ThermalSetAndSurfaceDuplicatesExpandOnce) {
|
|
auto deck =
|
|
Replace(ThermalDeck(), "*Elset, elset=E\n1\n", "*Elset, elset=E\n1,1\n");
|
|
deck = Replace(
|
|
deck, "*End Assembly",
|
|
"*Surface, type=ELEMENT, name=S\nI.1, SPOS\nI.1, SPOS\n*End Assembly");
|
|
const auto result = MapText(deck);
|
|
ASSERT_TRUE(result.HasValue());
|
|
EXPECT_EQ(result.Value().ThermalElements().Size(), 1U);
|
|
ASSERT_EQ(result.Value().ElementSurfaces().size(), 1U);
|
|
EXPECT_EQ(result.Value().ElementSurfaces()[0].facets.size(), 1U);
|
|
EXPECT_EQ(result.Value().Warnings().size(), 1U);
|
|
ExpectRejected(Replace(deck, "I.1, SPOS\nI.1, SPOS", "I.1, SPOS\nI.1, SNEG"),
|
|
"SURFACE");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping,
|
|
DeferredFailuresRetainExactInputLocationAndIdentity) {
|
|
auto deck = Replace(ThermalDeck(), "inc=100", "inc=99");
|
|
const TemporaryInput input{deck};
|
|
const auto parsed = fesa::AbaqusInputReader{}.Read(input.Path());
|
|
ASSERT_TRUE(parsed.HasValue());
|
|
const auto result = fesa::AbaqusDomainMapper{}.Map(parsed.Value());
|
|
ASSERT_FALSE(result.HasValue());
|
|
const auto& diagnostic = result.GetStatus().Diagnostics()[0];
|
|
EXPECT_EQ(diagnostic.location.file, input.Path());
|
|
EXPECT_EQ(diagnostic.location.line, LineOf(deck, "1., 100."));
|
|
EXPECT_EQ(diagnostic.keyword, "HEAT TRANSFER");
|
|
EXPECT_EQ(diagnostic.entity_identity, "Heat");
|
|
auto preprint =
|
|
std::string{"*Preprint, echo=NO, model=NO, history=NO\n"} + ThermalDeck();
|
|
const auto missing_contact = MapText(preprint);
|
|
ASSERT_FALSE(missing_contact.HasValue());
|
|
EXPECT_EQ(missing_contact.GetStatus().Diagnostics()[0].location.line, 1U);
|
|
EXPECT_EQ(missing_contact.GetStatus().Diagnostics()[0].keyword, "PREPRINT");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, RejectsMixedElementsAndWrongThermalMaterialScopes) {
|
|
ExpectRejected(Replace(ThermalDeck(), "*Elset, elset=E",
|
|
"*Element, type=S4\n2,1,2,3,4\n*Elset, elset=E"),
|
|
"ELEMENT");
|
|
for (const std::string block :
|
|
{"*Conductivity\n54\n", "*Specific Heat\n460\n",
|
|
"*Initial Conditions, type=TEMPERATURE\n1, 1\n"}) {
|
|
ExpectRejected(Replace(ThermalDeck(), "*End Part", block + "*End Part"));
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), "*End Assembly", block + "*End Assembly"));
|
|
ExpectRejected(Replace(ThermalDeck(), "*End Step", block + "*End Step"));
|
|
}
|
|
for (const std::string property :
|
|
{"*Conductivity\n54.,\n", "*Specific Heat\n460.,\n"}) {
|
|
auto deck = Replace(ThermalDeck(), property, "");
|
|
deck = Replace(deck, "*Material", property + "*Material");
|
|
ExpectRejected(deck);
|
|
}
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, InlineElementSetResolvesSectionCaseInsensitively) {
|
|
auto deck = Replace(ThermalDeck(), "*Element, type=DS4",
|
|
"*Element, type=ds4, elset=inlineShells");
|
|
deck = Replace(deck, "*Elset, elset=E\n1\n", "");
|
|
deck = Replace(deck, "*Shell Section, elset=E",
|
|
"*Shell Section, elset=INLINESHELLS");
|
|
const TemporaryInput input{deck};
|
|
const auto parsed = fesa::AbaqusInputReader{}.Read(input.Path());
|
|
ASSERT_TRUE(parsed.HasValue());
|
|
const auto result = fesa::AbaqusDomainMapper{}.Map(parsed.Value());
|
|
ASSERT_TRUE(result.HasValue())
|
|
<< result.GetStatus().Diagnostics().front().message;
|
|
const auto& domain = result.Value();
|
|
ASSERT_EQ(domain.ElementSets().size(), 1U);
|
|
const auto& set = domain.ElementSets()[0];
|
|
EXPECT_EQ(set.name, "inlineShells");
|
|
EXPECT_EQ(set.instance_name, "I");
|
|
EXPECT_EQ(set.element_indices, std::vector<fesa::EntityIndex>{0U});
|
|
EXPECT_EQ(set.location.file, input.Path());
|
|
EXPECT_EQ(set.location.line, LineOf(deck, "*Element"));
|
|
ASSERT_EQ(domain.ThermalElements().Size(), 1U);
|
|
EXPECT_EQ(domain.ThermalElements()[0].ThermalSectionIndex(), 0U);
|
|
EXPECT_EQ(domain.ThermalSections()[0].name, "INLINESHELLS");
|
|
EXPECT_EQ(domain.ThermalSections()[0].location.line,
|
|
LineOf(deck, "*Shell Section"));
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, InlineElementSetPreservesElementRowOrder) {
|
|
auto deck = Replace(ThermalDeck(), "*Element, type=DS4\n1, 1, 2, 3, 4",
|
|
"5,2,0,0\n6,3,0,0\n7,3,1,0\n8,2,1,0\n"
|
|
"*Element, type=DS4, elset=E\n7,1,2,3,4\n3,5,6,7,8");
|
|
deck = Replace(deck, "*Elset, elset=E\n1\n", "");
|
|
const auto result = MapText(deck);
|
|
ASSERT_TRUE(result.HasValue())
|
|
<< result.GetStatus().Diagnostics().front().message;
|
|
const auto& domain = result.Value();
|
|
ASSERT_EQ(domain.ElementSets().size(), 1U);
|
|
ASSERT_EQ(domain.ElementSets()[0].element_indices.size(), 2U);
|
|
EXPECT_EQ(domain.ElementSets()[0].element_indices,
|
|
(std::vector<fesa::EntityIndex>{0U, 1U}));
|
|
EXPECT_EQ(domain.ThermalElements()[0].SourceId().source_label, 7);
|
|
EXPECT_EQ(domain.ThermalElements()[1].SourceId().source_label, 3);
|
|
EXPECT_EQ(domain.ThermalElements()[0].ThermalSectionIndex(), 0U);
|
|
EXPECT_EQ(domain.ThermalElements()[1].ThermalSectionIndex(), 0U);
|
|
}
|
|
|
|
TEST(ThermalDomainMapping,
|
|
InlineElementSetRejectsInvalidAndDuplicateDefinitions) {
|
|
auto deck = Replace(ThermalDeck(), "*Elset, elset=E\n1\n", "");
|
|
for (const std::string option :
|
|
{"elset", "elset=", "elset=E, unknown=1", "elset=E, elset=e"}) {
|
|
SCOPED_TRACE(option);
|
|
const auto result = MapText(
|
|
Replace(deck, "*Element, type=DS4", "*Element, type=DS4, " + option));
|
|
ASSERT_FALSE(result.HasValue());
|
|
EXPECT_EQ(result.GetStatus().Diagnostics()[0].keyword, "ELEMENT");
|
|
EXPECT_EQ(result.GetStatus().Diagnostics()[0].location.line,
|
|
LineOf(deck, "*Element"));
|
|
}
|
|
ExpectRejected(Replace(ThermalDeck(), "*Element, type=DS4",
|
|
"*Element, type=DS4, elset=e"),
|
|
"ELSET");
|
|
deck = Replace(deck, "*Element, type=DS4", "*Element, type=DS4, elset=E");
|
|
ExpectRejected(
|
|
Replace(deck, "*Shell Section",
|
|
"*Element, type=DS4, elset=e\n2,1,2,3,4\n*Shell Section"),
|
|
"ELEMENT");
|
|
auto conflicting =
|
|
Replace(deck, "*Shell Section", "*Elset, elset=Other\n1\n*Shell Section");
|
|
conflicting =
|
|
Replace(conflicting, "*End Part",
|
|
"*Shell Section, elset=Other, material=M\n.5\n*End Part");
|
|
ExpectRejected(conflicting, "SHELL SECTION");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, RejectsBeamSectionAndBeamOnlyChildrenAtTheirSource) {
|
|
const std::string beam =
|
|
"*Beam General Section, elset=E, material=M, "
|
|
"section=GENERAL\n1,1,0,1,1\n1,0,0\n";
|
|
for (const std::string suffix :
|
|
{"", "*Section Points\n0,0\n", "*Transverse Shear Stiffness\n1,1,1\n"}) {
|
|
const auto deck =
|
|
Replace(ThermalDeck(), "*End Part", beam + suffix + "*End Part");
|
|
const auto result = MapText(deck);
|
|
ASSERT_FALSE(result.HasValue());
|
|
EXPECT_EQ(result.GetStatus().Diagnostics()[0].keyword,
|
|
"BEAM GENERAL SECTION");
|
|
EXPECT_EQ(result.GetStatus().Diagnostics()[0].location.line,
|
|
LineOf(deck, "*Beam General Section"));
|
|
}
|
|
ExpectRejected(
|
|
Replace(ThermalDeck(), "*End Part", "*Section Points\n0,0\n*End Part"),
|
|
"SECTION POINTS");
|
|
ExpectRejected(Replace(ThermalDeck(), "*End Part",
|
|
"*Transverse Shear Stiffness\n1,1,1\n*End Part"),
|
|
"TRANSVERSE SHEAR STIFFNESS");
|
|
}
|
|
|
|
TEST(ThermalDomainMapping, RejectsMalformedDs4ConnectivityAndElementOptions) {
|
|
for (const std::string row :
|
|
{"1,1,2,3", "1,1,2,3,4,1", "1,1,2,3,3", "1,0,2,3,4", "1,-1,2,3,4",
|
|
"1,1.5,2,3,4", "1,1,2,3,99", "0,1,2,3,4", "1.5,1,2,3,4",
|
|
"1,1,2,3,4\n1,1,2,3,4"}) {
|
|
SCOPED_TRACE(row);
|
|
ExpectRejected(Replace(ThermalDeck(), "1, 1, 2, 3, 4", row), "ELEMENT");
|
|
}
|
|
ExpectRejected(Replace(ThermalDeck(), "*Element, type=DS4",
|
|
"*Element, type=DS4, unknown=1"),
|
|
"ELEMENT");
|
|
}
|
|
|
|
} // namespace
|